v0.148.x stable

This PR changes how we ask users to draft up PRs and how release note
generation happens.

We no longer force the user to create the markdown URL link, but we do
ask them to use the `closes` [GitHub magic
word](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)
to link the PR to an issue, so that the issue is closed automatically
when closing the PR.

As for the changelog release notes, we are no longer linking to the
issues, but the PR itself, which should contain the issue if a reader
wants to dive further back. This makes our output more consistent, as
every line will have a link, even if there is no issue associated, and
it removes the need for us to try to parse the issue url in the body to
try to correct mistakes in how they were forming Markdown urls - the PR
url is always returned in the request, which makes it easy. **Lastly,
it's just a lot less annoying to make the release notes.**

The new PR format will be:

```
Closes #ISSUE

Release Notes:

- Added/Fixed/Improved ...
```

The new script output format will be:

```
PR Title: theme: Use a non-transparent color for the fallback `title_bar.inactive_background`
Credit: ([#15709](https://github.com/zed-industries/zed/pull/15709); thanks [maxdeviant](https://github.com/maxdeviant))
Release Notes:

- linux: Changed the fallback color of `title_bar.inactive_background` to a non-transparent value.
--------------------------------------------------------------------------------
PR Title: Skip over folded regions when iterating over multibuffer chunks
Credit: ([#15646](https://github.com/zed-industries/zed/pull/15646); thanks [osiewicz](https://github.com/osiewicz))
Release Notes:

- Fixed poor performance when editing in the assistant panel after inserting large files using slash commands
--------------------------------------------------------------------------------
```

This still requires us to manually apply the credit line, but the line
is already fully formed, so this should still be faster than having to
manually create that line / fix any line where someone messed it up
(which was all the time). I would just automatically apply it to the
release notes, but sometimes we have multiple bullet points in a single
PR and no real structure is enforced, so I foresee doing anything
automatic breaking and needing manual adjustment.

Release Notes:

- N/A

.github/workflows/ci.yml

@@ -167,7 +167,6 @@ jobs:
       APPLE_NOTARIZATION_USERNAME: ${{ secrets.APPLE_NOTARIZATION_USERNAME }}
       APPLE_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_NOTARIZATION_PASSWORD }}
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
-      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
     steps:
@@ -232,20 +231,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@834a144ee995460fba8ed112a2fc961b36a5ec5a # v4
+        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # 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@834a144ee995460fba8ed112a2fc961b36a5ec5a # v4
+        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # 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@834a144ee995460fba8ed112a2fc961b36a5ec5a # v4
+        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # 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
@@ -277,7 +276,6 @@ jobs:
     needs: [linux_tests]
     env:
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
-      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Add Rust to the PATH
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
@@ -321,7 +319,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@834a144ee995460fba8ed112a2fc961b36a5ec5a # v4
+        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # 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
@@ -348,7 +346,6 @@ jobs:
     needs: [linux_tests]
     env:
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
-      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
@@ -406,7 +403,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@834a144ee995460fba8ed112a2fc961b36a5ec5a # v4
+        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # 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/release_actions.yml

@@ -16,7 +16,7 @@ jobs:
           fi
           echo "::set-output name=URL::$URL"
       - name: Get content
-        uses: 2428392/gh-truncate-string-action@e6b5885fb83c81ca9a700a91b079baec2133be3e # v1.4.0
+        uses: 2428392/gh-truncate-string-action@67b1b814955634208b103cff064be3cb1c7a19be # v1.3.0
         id: get-content
         with:
           stringToTruncate: |

.github/workflows/release_nightly.yml

@@ -67,7 +67,6 @@ jobs:
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
-      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Install Node
         uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
@@ -107,7 +106,6 @@ jobs:
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
-      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
@@ -141,7 +139,6 @@ jobs:
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
-      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4

.zed/tasks.json

@@ -3,10 +3,5 @@
     "label": "clippy",
     "command": "./script/clippy",
     "args": []
-  },
-  {
-    "label": "cargo run --profile release-fast",
-    "command": "cargo",
-    "args": ["run", "--profile", "release-fast"]
   }
 ]

Cargo.toml

@@ -19,7 +19,6 @@ members = [
     "crates/collections",
     "crates/command_palette",
     "crates/command_palette_hooks",
-    "crates/context_servers",
     "crates/copilot",
     "crates/db",
     "crates/dev_server_projects",
@@ -70,7 +69,6 @@ members = [
     "crates/outline",
     "crates/outline_panel",
     "crates/paths",
-    "crates/performance",
     "crates/picker",
     "crates/prettier",
     "crates/project",
@@ -146,12 +144,10 @@ members = [
     "extensions/lua",
     "extensions/ocaml",
     "extensions/php",
-    "extensions/perplexity",
     "extensions/prisma",
     "extensions/purescript",
     "extensions/ruff",
     "extensions/ruby",
-    "extensions/slash-commands-example",
     "extensions/snippets",
     "extensions/svelte",
     "extensions/terraform",
@@ -193,7 +189,6 @@ collab_ui = { path = "crates/collab_ui" }
 collections = { path = "crates/collections" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
-context_servers = { path = "crates/context_servers" }
 copilot = { path = "crates/copilot" }
 db = { path = "crates/db" }
 dev_server_projects = { path = "crates/dev_server_projects" }
@@ -243,7 +238,6 @@ open_ai = { path = "crates/open_ai" }
 outline = { path = "crates/outline" }
 outline_panel = { path = "crates/outline_panel" }
 paths = { path = "crates/paths" }
-performance = { path = "crates/performance" }
 picker = { path = "crates/picker" }
 plugin = { path = "crates/plugin" }
 plugin_macros = { path = "crates/plugin_macros" }
@@ -467,7 +461,7 @@ which = "6.0.0"
 wit-component = "0.201"
 
 [workspace.dependencies.async-stripe]
-version = "0.38"
+version = "0.37"
 default-features = false
 features = [
     "runtime-tokio-hyper-rustls",

Procfile.postgrest

@@ -1,2 +0,0 @@
-app: postgrest crates/collab/postgrest_app.conf
-llm: postgrest crates/collab/postgrest_llm.conf

assets/icons/ai_anthropic.svg

@@ -1,11 +1,4 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0_1896_18)">
-<path d="M11.094 3.09999H8.952L12.858 12.9H15L11.094 3.09999Z" fill="#1F1F1E"/>
-<path d="M4.906 3.09999L1 12.9H3.184L3.98284 10.842H8.06915L8.868 12.9H11.052L7.146 3.09999H4.906ZM4.68928 9.02199L6.026 5.57799L7.3627 9.02199H4.68928Z" fill="#1F1F1E"/>
-</g>
-<defs>
-<clipPath id="clip0_1896_18">
-<rect width="14" height="9.8" fill="white" transform="translate(1 3.09999)"/>
-</clipPath>
-</defs>
+<path d="M3.43331 10.1846L6.66616 2.33334L9.89902 10.1846M3.43331 10.1846L1.9995 13.6667M3.43331 10.1846H9.89902M11.3328 13.6667L9.89902 10.1846" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M14.0613 13.647L9.34721 2.33334" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>

assets/icons/ai_anthropic_hosted.svg

@@ -1,12 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect width="16" height="16" rx="2" fill="black" fill-opacity="0.2"/>
-<g clip-path="url(#clip0_1916_18)">
-<path d="M10.652 3.79999H8.816L12.164 12.2H14L10.652 3.79999Z" fill="#1F1F1E"/>
-<path d="M5.348 3.79999L2 12.2H3.872L4.55672 10.436H8.05927L8.744 12.2H10.616L7.268 3.79999H5.348ZM5.16224 8.87599L6.308 5.92399L7.45374 8.87599H5.16224Z" fill="#1F1F1E"/>
-</g>
-<defs>
-<clipPath id="clip0_1916_18">
-<rect width="12" height="8.4" fill="white" transform="translate(2 3.79999)"/>
-</clipPath>
-</defs>
-</svg>

assets/icons/ai_google.svg

@@ -1,3 +1,3 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M13.8695 8.14262C13.8695 11.6221 11.4867 14.0984 7.96785 14.0984C4.59408 14.0984 1.86949 11.3738 1.86949 7.99999C1.86949 4.62622 4.59408 1.90163 7.96785 1.90163C9.61048 1.90163 10.9924 2.50409 12.0572 3.49754L10.3974 5.09344C8.22605 2.99836 4.18834 4.57213 4.18834 7.99999C4.18834 10.127 5.88752 11.8508 7.96785 11.8508C10.3826 11.8508 11.2875 10.1197 11.4301 9.22213H7.96785V7.12458H13.7736C13.8301 7.43688 13.8695 7.73688 13.8695 8.14262Z" fill="black"/>
+<path d="M14.8695 8.16639C14.8695 12.2258 12.0896 15.1147 7.98425 15.1147C4.04818 15.1147 0.869492 11.9361 0.869492 7.99999C0.869492 4.06393 4.04818 0.885239 7.98425 0.885239C9.90064 0.885239 11.5129 1.58811 12.7551 2.74712L10.8187 4.60901C8.28547 2.16475 3.57482 4.00081 3.57482 7.99999C3.57482 10.4816 5.5572 12.4926 7.98425 12.4926C10.8015 12.4926 11.8572 10.4729 12.0236 9.42581H7.98425V6.97868H14.7576C14.8236 7.34303 14.8695 7.69303 14.8695 8.16639Z" fill="black"/>
 </svg>

assets/icons/database_zap.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-database-zap"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 15 21.84"/><path d="M21 5V8"/><path d="M21 12L18 17H22L19 22"/><path d="M3 12A9 3 0 0 0 14.59 14.87"/></svg>

assets/icons/ellipsis_vertical.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-ellipsis-vertical"><circle cx="12" cy="12" r="1"/><circle cx="12" cy="5" r="1"/><circle cx="12" cy="19" r="1"/></svg>

assets/icons/magic_wand.svg

@@ -0,0 +1,10 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M3 13L7.01562 8.98438" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M8.6875 7.3125L9.5 6.5" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M7 5V3" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M12 5V3" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M12 10V8" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M6 4L8 4" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M11 4L13 4" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+    <path d="M11 9L13 9" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+</svg>

assets/icons/microscope.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-microscope"><path d="M6 18h8"/><path d="M3 22h18"/><path d="M14 22a7 7 0 1 0 0-14h-1"/><path d="M9 14h2"/><path d="M9 12a2 2 0 0 1-2-2V6h6v4a2 2 0 0 1-2 2Z"/><path d="M12 6V3a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3"/></svg>

assets/icons/search_code.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-search-code"><path d="m13 13.5 2-2.5-2-2.5"/><path d="m21 21-4.3-4.3"/><path d="M9 8.5 7 11l2 2.5"/><circle cx="11" cy="11" r="8"/></svg>

assets/icons/slash_square.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-square-slash"><rect width="18" height="18" x="3" y="3" rx="2"/><line x1="9" x2="15" y1="15" y2="9"/></svg>

assets/icons/text-search.svg

@@ -1 +1 @@
-<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-slash"><path d="M22 2 2 22"/></svg>
+<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-text-search"><path d="M21 6H3"/><path d="M10 12H3"/><path d="M10 18H3"/><circle cx="17" cy="15" r="3"/><path d="m21 19-1.9-1.9"/></svg>

assets/icons/text_select.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-text-select"><path d="M5 3a2 2 0 0 0-2 2"/><path d="M19 3a2 2 0 0 1 2 2"/><path d="M21 19a2 2 0 0 1-2 2"/><path d="M5 21a2 2 0 0 1-2-2"/><path d="M9 3h1"/><path d="M9 21h1"/><path d="M14 3h1"/><path d="M14 21h1"/><path d="M3 9v1"/><path d="M21 9v1"/><path d="M3 14v1"/><path d="M21 14v1"/><line x1="7" x2="15" y1="8" y2="8"/><line x1="7" x2="17" y1="12" y2="12"/><line x1="7" x2="13" y1="16" y2="16"/></svg>

assets/icons/undo.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-undo"><path d="M3 7v6h6"/><path d="M21 17a9 9 0 0 0-9-9 9 9 0 0 0-6 2.3L3 13"/></svg>

assets/keymaps/default-linux.json

@@ -437,7 +437,7 @@
     "context": "Editor && showing_completions",
     "bindings": {
       "enter": "editor::ConfirmCompletion",
-      "tab": "editor::ComposeCompletion"
+      "tab": "editor::ConfirmCompletion"
     }
   },
   {

assets/keymaps/default-macos.json

@@ -474,7 +474,7 @@
     "context": "Editor && showing_completions",
     "bindings": {
       "enter": "editor::ConfirmCompletion",
-      "tab": "editor::ComposeCompletion"
+      "tab": "editor::ConfirmCompletion"
     }
   },
   {

assets/keymaps/vim.json

@@ -4,6 +4,7 @@
     "bindings": {
       "i": ["vim::PushOperator", { "Object": { "around": false } }],
       "a": ["vim::PushOperator", { "Object": { "around": true } }],
+      ":": "command_palette::Toggle",
       "h": "vim::Left",
       "left": "vim::Left",
       "backspace": "vim::Backspace",
@@ -198,12 +199,17 @@
       "ctrl-6": "pane::AlternateFile"
     }
   },
+  {
+    "context": "VimControl && VimCount",
+    "bindings": {
+      "0": ["vim::Number", 0]
+    }
+  },
   {
     "context": "vim_mode == normal",
     "bindings": {
       "escape": "editor::Cancel",
       "ctrl-[": "editor::Cancel",
-      ":": "command_palette::Toggle",
       ".": "vim::Repeat",
       "c": ["vim::PushOperator", "Change"],
       "shift-c": "vim::ChangeToEndOfLine",
@@ -251,17 +257,9 @@
       "g c": ["vim::PushOperator", "ToggleComments"]
     }
   },
-  {
-    "context": "VimControl && VimCount",
-    "bindings": {
-      "0": ["vim::Number", 0],
-      ":": "vim::CountCommand"
-    }
-  },
   {
     "context": "vim_mode == visual",
     "bindings": {
-      ":": "vim::VisualCommand",
       "u": "vim::ConvertToLowerCase",
       "U": "vim::ConvertToUpperCase",
       "o": "vim::OtherEnd",

assets/prompts/content_prompt.hbs

@@ -32,7 +32,7 @@ Match the indentation in the original file in the inserted {{content_type}}, don
 Immediately start with the following format with no remarks:
 
 ```
-\{{INSERTED_CODE}}
+{{INSERTED_CODE}}
 ```
 {{else}}
 Edit the section of {{content_type}} in <rewrite_this></rewrite_this> tags based on the following prompt:
@@ -56,6 +56,6 @@ Start at the indentation level in the original file in the rewritten {{content_t
 Immediately start with the following format with no remarks:
 
 ```
-\{{REWRITTEN_CODE}}
+{{REWRITTEN_CODE}}
 ```
 {{/if}}

assets/prompts/edit_workflow.hbs

@@ -1,302 +1,87 @@
-<workflow>
 Guide the user through code changes in numbered steps that focus on individual functions, type definitions, etc.
-Surround each distinct step in a <step></step> XML tag. The user will be performing these steps in a code editor
-named Zed, which is where they will have entered this prompt and will be seeing the response.
+Surround each distinct step in a <step></step> XML tag.
 
-<instructions>
-- Use the language of the file for code fence blocks unless otherwise specified.
-- Include a code or file action in each step.
-- Only put code in separate steps if it should either go in separate files, or in different (non-contiguous) places in the same file.
-- Provide error handling and input validation where appropriate.
-- Adapt explanations based on the user's perceived level of expertise.
-- Include comments in code examples to enhance understanding.
-- Consider more complex programming scenarios when relevant.
-- Avoid using the terminal to perform filesystem operations such as creating, deleting, renaming, and editing files. Assume the user prefers to use Zed for these operations, unless the prompt suggests that the user is expecting terminal commands.
-- When creating a new file, Zed will automatically create any necessary directories in that file's path. So when a step will create a new file in Zed, don't mention needing to create the directory that it will go in.
-- Assume the user is performing these actions in the Zed code editor, so avoid redundancies like "In your code editor, ..." or "In Zed, ..."
-- Be concise without leaving out important information.
-</instructions>
+Here's an example of a user-assistant dialog with step numbers and a follow-up question in Rust:
 
-Examples of user-assistant dialogs with step numbers and user follow-up requests:
-
-<example language="rust">
-<turn number="1">
-<user>Create a Library struct with a vector of Book structs. Include methods to add books and find books by author. Use generics for the book ID.</user>
-<assistant>Certainly! Let's create a Library struct with a vector of Book structs, including methods to add books and find books by author, using generics for the book ID:
-
-<step>Define the Book and Library structs
+1. User: I want to create a User struct with name and age fields, and a method to print the user's information. Can you help me with that?
+A: Certainly! Let's create a User struct with the specified fields and a method to print the information:
+<step>Define the User struct
 ```rust
-use std::fmt::Display;
-
-struct Book<T>
-where
-    T: Display + Clone
-{
-    id: T,
-    title: String,
-    author: String,
-}
-
-struct Library<T>
-where
-    T: Display + Clone
-{
-    books: Vec<Book<T>>,
+struct User {
+    name: String,
+    age: u32,
 }
 ```
 </step>
-<step>Implement methods for the Library struct
+<step>Implement methods for the User struct
 ```rust
-impl<T> Library<T>
-where
-    T: Display + Clone
-{
-    fn new() -> Self {
-        Library { books: Vec::new() }
+impl User {
+    fn new(name: String, age: u32) -> Self {
+        User { name, age }
     }
-
-    fn add_book(&mut self, id: T, title: String, author: String) {
-        let book = Book { id, title, author };
-        self.books.push(book);
-    }
-
-    fn find_books_by_author(&self, author: &str) -> Vec<&Book<T>> {
-        self.books
-            .iter()
-            .filter(|book| book.author.to_lowercase() == author.to_lowercase())
-            .collect()
+    fn print_info(&self) {
+        println!("Name: {}, Age: {}", self.name, self.age);
     }
 }
 ```
 </step>
 
-This code defines:
-1. A generic Book struct with an ID of type T, title, and author
-2. A Library struct containing a vector of Books
-3. Methods to create a new Library, add books, and find books by author
-The use of generics allows flexibility in the type of ID used for books.</assistant>
-</turn>
+This code defines a User struct and implements two methods:
+- `new`: a constructor to create a new User
+- `print_info`: a method to print the user's information
 
-<turn number="2">
-<user>How can I use this Library struct in a main function?</user>
-<assistant>Here's how you can use the Library struct in a main function:
+2. User: Great! Now, how can I create a User instance and call the print_info method?
+A: You can create a User instance and call the print_info method like this:
 
-<step>Create a main function to demonstrate Library usage
+<step>Create a User instance and call print_info
 ```rust
 fn main() {
-    // Create a new Library with string IDs
-    let mut library = Library::new();
-
-    // Add some books
-    library.add_book(String::from("001"), String::from("The Rust Programming Language"), String::from("Steve Klabnik"));
-    library.add_book(String::from("002"), String::from("Programming Rust"), String::from("Jim Blandy"));
-    library.add_book(String::from("003"), String::from("Rust in Action"), String::from("Tim McNamara"));
-
-    // Find books by author
-    let author = "Steve Klabnik";
-    let books = library.find_books_by_author(author);
-
-    println!("Books by {}:", author);
-    for book in books {
-        println!("ID: {}, Title: {}", book.id, book.title);
-    }
+    let user = User::new(String::from("Alice"), 30);
+    user.print_info();
 }
 ```
 </step>
 
-This main function demonstrates:
-1. Creating a new Library instance
-2. Adding books with string IDs
-3. Finding and displaying books by a specific author</assistant>
-</turn>
+This will output: `Name: Alice, Age: 30`
 
-<turn number="3">
-<user>Can you add a method to remove a book by ID and handle potential errors?</user>
-<assistant>Certainly! Let's add a method to remove a book by ID and handle potential errors:
+3. User: Can you add an email field to the User struct and update the print_info method to include it?
+A: Certainly! Let's modify the User struct and update the print_info method:
 
-<step>Add a remove_book method to the Library struct
+<step>Add email field to User struct
 ```rust
-use std::fmt::Display;
-use std::error::Error;
-use std::fmt;
-
-#[derive(Debug)]
-struct BookNotFoundError;
-
-impl Error for BookNotFoundError {}
-
-impl fmt::Display for BookNotFoundError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Book not found")
-    }
+struct User {
+    name: String,
+    age: u32,
+    email: String,
 }
+```
+</step>
 
-impl<T> Library<T>
-where
-    T: Display + Clone + PartialEq
-{
-    // ... (previous methods remain the same)
-
-    fn remove_book(&mut self, id: &T) -> Result<Book<T>, BookNotFoundError> {
-        if let Some(index) = self.books.iter().position(|book| &book.id == id) {
-            Ok(self.books.remove(index))
-        } else {
-            Err(BookNotFoundError)
-        }
+<step>Update the new method and print_info method
+```rust
+impl User {
+    fn new(name: String, age: u32, email: String) -> Self {
+        User { name, age, email }
+    }
+    fn print_info(&self) {
+        println!("Name: {}, Age: {}, Email: {}", self.name, self.age, self.email);
     }
 }
 ```
 </step>
-<step>Update the main function to demonstrate book removal
+
+<step>Update the main function
 ```rust
 fn main() {
-    // ... (previous code remains the same)
-
-    // Attempt to remove a book
-    let id_to_remove = String::from("002");
-    match library.remove_book(&id_to_remove) {
-        Ok(removed_book) => println!("Removed book: {} by {}", removed_book.title, removed_book.author),
-        Err(e) => println!("Error removing book: {}", e),
-    }
-
-    // Attempt to remove a non-existent book
-    let non_existent_id = String::from("999");
-    match library.remove_book(&non_existent_id) {
-        Ok(_) => println!("Book removed successfully"),
-        Err(e) => println!("Error removing book: {}", e),
-    }
-
-    // Display remaining books
-    println!("\nRemaining books:");
-    for book in &library.books {
-        println!("ID: {}, Title: {} by {}", book.id, book.title, book.author);
-    }
+    let user = User::new(String::from("Alice"), 30, String::from("alice@example.com"));
+    user.print_info();
 }
 ```
 </step>
 
-This update includes:
-1. A new remove_book method that returns a Result type
-2. A custom BookNotFoundError for error handling
-3. Demonstration of successful book removal and error handling for non-existent books
-4. Display of remaining books after removal attempts
-
-The remove_book method uses the PartialEq trait to compare book IDs, allowing for flexible ID types while maintaining type safety.</assistant>
-</turn>
-</example>
-
-<example language="go">
-<turn number="1">
-<user>Create a Person struct with name, age, and email fields, and a method to greet. Include error handling for age.</user>
-<assistant>Certainly! Let's create a Person struct with the specified fields and a method to greet in Go:
-
-<step>Define the Person struct and NewPerson function with error handling
-```go
-type Person struct {
-    Name  string
-    Age   int
-    Email string
-}
-
-func NewPerson(name string, age int, email string) (*Person, error) {
-    if age < 0 || age > 150 {
-        return nil, fmt.Errorf("invalid age: %d", age)
-    }
-    return &Person{Name: name, Age: age, Email: email}, nil
-}
-```
-</step>
-<step>Implement the Greet method for the Person struct
-```go
-func (p *Person) Greet() string {
-    return fmt.Sprintf("Hello, I'm %s, %d years old. You can reach me at %s.", p.Name, p.Age, p.Email)
-}
-```
-</step>
-
-This code defines a Person struct, a NewPerson function with age validation, and a Greet method.</assistant>
-</turn>
-
-<turn number="2">
-<user>How can I use these in a main function?</user>
-<assistant>Here's how to use the Person struct and its methods in a main function:
-
-<step>Create a main function with error handling
-```go
-func main() {
-    // Create a new Person instance
-    person, err := NewPerson("Alice", 30, "alice@example.com")
-    if err != nil {
-        fmt.Println("Error creating person:", err)
-        return
-    }
-
-    // Use the Greet method
-    fmt.Println(person.Greet())
-
-    // Demonstrate error handling with invalid age
-    invalidPerson, err := NewPerson("Bob", 200, "bob@example.com")
-    if err != nil {
-        fmt.Println("Error creating person with invalid age:", err)
-    }
-}
-```
-</step>
-
-This main function demonstrates:
-1. Creating a valid Person instance
-2. Using the Greet method
-3. Handling errors when creating a Person with an invalid age</assistant>
-</turn>
-
-<turn number="3">
-<user>Can you add a method to update the email with validation?</user>
-<assistant>Certainly! Let's add a method to update the email with validation:
-
-<step>Add UpdateEmail method with validation
-```go
-import (
-    "fmt"
-    "regexp"
-)
-
-func (p *Person) UpdateEmail(newEmail string) error {
-    // Simple email validation using regex
-    emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
-    if !emailRegex.MatchString(newEmail) {
-        return fmt.Errorf("invalid email format: %s", newEmail)
-    }
-    p.Email = newEmail
-    return nil
-}
-```
-</step>
-<step>Update the main function to demonstrate email update
-```go
-func main() {
-    // ... (previous code remains the same)
-
-    // Demonstrate email update
-    err = person.UpdateEmail("alice.new@example.com")
-    if err != nil {
-        fmt.Println("Error updating email:", err)
-    } else {
-        fmt.Println("Updated greeting:", person.Greet())
-    }
-
-    // Demonstrate email update with invalid email
-    err = person.UpdateEmail("invalid-email")
-    if err != nil {
-        fmt.Println("Error updating email:", err)
-    }
-}
-```
-</step>
-
-This update includes:
-1. An UpdateEmail method with email format validation
-2. Demonstration of successful email update in the main function
-3. Handling of invalid email update attempt</assistant>
-</turn>
-</example>
-</workflow>
+This will now output: `Name: Alice, Age: 30, Email: alice@example.com`
+The changes include:
+1. Adding the `email` field to the User struct
+2. Updating the `new` method to accept an email parameter
+3. Modifying the `print_info` method to include the email
+4. Updating the main function to provide an email when creating a User instance

assets/prompts/step_resolution.hbs

@@ -1,28 +1,22 @@
-<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.
+Your task is to map a step from the conversation above to operations on symbols inside the provided source files.
 
-<guidelines>
+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.
+- Don't create and then update a file.
+- We'll create it in one 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.
+- Never include operations on a parent symbol and one of its children in the same operations block.
+- Never nest an operation with another operation or include CDATA or other content. All operations are leaf nodes.
+- Include a description attribute for each operation with a brief, one-line description of the change to perform.
+- Descriptions are required for all operations except delete.
+- When generating multiple operations, 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>
+- Don't generate multiple operations at the same location. Instead, combine them together in a single operation with a succinct combined description.
 
-<examples>
-<example>
-<workflow_context>
-<message role="user">
+Example 1:
+
+User:
 ```rs src/rectangle.rs
 struct Rectangle {
     width: f64,
@@ -36,24 +30,15 @@ impl Rectangle {
 }
 ```
 
-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>
+What are the operations for the step: <step>Add a new method 'calculate_area' to the Rectangle struct</step>
 
-<incorrect_output reason="NEVER append multiple children at the same location.">
+A (wrong):
 {
   "title": "Add Rectangle methods",
-  "suggestions": [
+  "operations": [
     {
       "kind": "AppendChild",
       "path": "src/shapes.rs",
@@ -68,12 +53,13 @@ Add new methods 'calculate_area' and 'calculate_perimeter' to the Rectangle stru
     }
   ]
 }
-</incorrect_output>
 
-<correct_output>
+This demonstrates what NOT to do. NEVER append multiple children at the same location.
+
+A (corrected):
 {
   "title": "Add Rectangle methods",
-  "suggestions": [
+  "operations": [
     {
       "kind": "AppendChild",
       "path": "src/shapes.rs",
@@ -82,16 +68,14 @@ Add new methods 'calculate_area' and 'calculate_perimeter' to the Rectangle stru
     }
   ]
 }
-</correct_output>
 
-<step_to_resolve>
-Implement the 'Display' trait for the Rectangle struct
-</step_to_resolve>
+User:
+What are the operations for the step: <step>Implement the 'Display' trait for the Rectangle struct</step>
 
-<output>
+A:
 {
   "title": "Implement Display for Rectangle",
-  "suggestions": [
+  "operations": [
     {
       "kind": "InsertSiblingAfter",
       "path": "src/shapes.rs",
@@ -100,11 +84,10 @@ Implement the 'Display' trait for the Rectangle struct
     }
   ]
 }
-</output>
 
-<example>
-<workflow_context>
-<message role="user">
+Example 2:
+
+User:
 ```rs src/user.rs
 struct User {
     pub name: String,
@@ -122,22 +105,16 @@ impl User {
     }
 }
 ```
-</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>
+What are the operations for the step: <step>Update the 'print_info' method to use formatted output</step>
 
-<output>
+A:
 {
   "title": "Use formatted output",
-  "suggestions": [
+  "operations": [
     {
       "kind": "Update",
       "path": "src/user.rs",
@@ -146,16 +123,14 @@ Update the 'print_info' method to use formatted output
     }
   ]
 }
-</output>
 
-<step_to_resolve>
-Remove the 'email' field from the User struct
-</step_to_resolve>
+User:
+What are the operations for the step: <step>Remove the 'email' field from the User struct</step>
 
-<output>
+A:
 {
   "title": "Remove email field",
-  "suggestions": [
+  "operations": [
       {
         "kind": "Delete",
         "path": "src/user.rs",
@@ -163,12 +138,10 @@ Remove the 'email' field from the User struct
       }
     ]
 }
-</output>
-</example>
 
-<example>
-<workflow_context>
-<message role="user">
+Example 3:
+
+User:
 ```rs src/vehicle.rs
 struct Vehicle {
     make: String,
@@ -186,39 +159,31 @@ impl Vehicle {
     }
 }
 ```
-</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>
+What are the operations for the step: <step>Add a 'use std::fmt;' statement at the beginning of the file</step>
 
-<output>
+A:
 {
   "title": "Add use std::fmt statement",
-  "suggestions": [
+  "operations": [
     {
       "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>
+User:
+What are the operations for the step: <step>Add a new method 'start_engine' in the Vehicle impl block</step>
 
-<output>
+A:
 {
   "title": "Add start_engine method",
-  "suggestions": [
+  "operations": [
     {
       "kind": "InsertSiblingAfter",
       "path": "src/vehicle.rs",
@@ -227,12 +192,10 @@ Add a new method 'start_engine' in the Vehicle impl block
     }
   ]
 }
-</output>
-</example>
 
-<example>
-<workflow_context>
-<message role="user">
+Example 4:
+
+User:
 ```rs src/employee.rs
 struct Employee {
     name: String,
@@ -256,21 +219,15 @@ impl Employee {
     }
 }
 ```
-</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>
+What are the operations for the step: <step>Make salary an f32</step>
 
-<incorrect_output reason="NEVER include suggestions on a parent symbol and one of its children in the same suggestions block.">
+A (wrong):
 {
   "title": "Change salary to f32",
-  "suggestions": [
+  "operations": [
     {
       "kind": "Update",
       "path": "src/employee.rs",
@@ -285,12 +242,13 @@ Make salary an f32
     }
   ]
 }
-</incorrect_output>
 
-<correct_output>
+This example demonstrates what not to do. `struct Employee salary` is a child of `struct Employee`.
+
+A (corrected):
 {
   "title": "Change salary to f32",
-  "suggestions": [
+  "operations": [
     {
       "kind": "Update",
       "path": "src/employee.rs",
@@ -299,16 +257,14 @@ Make salary an f32
     }
   ]
 }
-</correct_output>
 
-<step_to_resolve>
-Remove the 'department' field and update the 'print_details' method
-</step_to_resolve>
+User:
+What are the correct operations for the step: <step>Remove the 'department' field and update the 'print_details' method</step>
 
-<output>
+A:
 {
   "title": "Remove department",
-  "suggestions": [
+  "operations": [
     {
       "kind": "Delete",
       "path": "src/employee.rs",
@@ -322,12 +278,10 @@ Remove the 'department' field and update the 'print_details' method
     }
   ]
 }
-</output>
-</example>
 
-<example>
-<workflow_context>
-<message role="user">
+Example 5:
+
+User:
 ```rs src/game.rs
 struct Player {
     name: String,
@@ -351,20 +305,13 @@ impl Game {
     }
 }
 ```
-</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>
+A:
 {
   "title": "Add level field to Player",
-  "suggestions": [
+  "operations": [
     {
       "kind": "InsertSiblingAfter",
       "path": "src/game.rs",
@@ -379,12 +326,10 @@ Add a 'level' field to Player and update the 'new' method
     }
   ]
 }
-</output>
-</example>
 
-<example>
-<workflow_context>
-<message role="user">
+Example 6:
+
+User:
 ```rs src/config.rs
 use std::collections::HashMap;
 
@@ -398,24 +343,16 @@ impl Config {
     }
 }
 ```
-</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>
+A:
 {
   "title": "Add load_from_file method",
-  "suggestions": [
+  "operations": [
     {
       "kind": "PrependChild",
       "path": "src/config.rs",
-      "symbol": "#imports",
       "description": "Import std::fs and std::io modules"
     },
     {
@@ -426,12 +363,10 @@ Add a 'load_from_file' method to Config and import necessary modules
     }
   ]
 }
-</output>
-</example>
 
-<example>
-<workflow_context>
-<message role="user">
+Example 7:
+
+User:
 ```rs src/database.rs
 pub(crate) struct Database {
     connection: Connection,
@@ -448,20 +383,13 @@ impl Database {
     }
 }
 ```
-</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>
+A:
 {
   "title": "Add error handling to query",
-  "suggestions": [
+  "operations": [
     {
       "kind": "PrependChild",
       "path": "src/database.rs",
@@ -481,16 +409,5 @@ Add error handling to the 'query' method and create a custom error type
     }
   ]
 }
-</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>
+Now generate the operations for the following step:

assets/settings/default.json

@@ -395,22 +395,9 @@
     // The default model to use when creating new contexts.
     "default_model": {
       // The provider to use.
-      "provider": "zed.dev",
+      "provider": "openai",
       // The model to use.
-      "model": "claude-3-5-sonnet"
-    }
-  },
-  // The settings for slash commands.
-  "slash_commands": {
-    // Settings for the `/docs` slash command.
-    "docs": {
-      // Whether `/docs` is enabled.
-      "enabled": false
-    },
-    // Settings for the `/project` slash command.
-    "project": {
-      // Whether `/project` is enabled.
-      "enabled": false
+      "model": "gpt-4o"
     }
   },
   // Whether the screen sharing icon is shown in the os status bar.
@@ -836,7 +823,6 @@
       "language_servers": ["starpls", "!buck2-lsp", "..."]
     },
     "Svelte": {
-      "language_servers": ["svelte-language-server", "..."],
       "prettier": {
         "allowed": true,
         "plugins": ["prettier-plugin-svelte"]
@@ -860,7 +846,6 @@
       }
     },
     "Vue.js": {
-      "language_servers": ["vue-language-server", "..."],
       "prettier": {
         "allowed": true
       }
@@ -1012,16 +997,5 @@
   //     ]
   //   }
   // ]
-  "ssh_connections": null,
-  // Configures the Context Server Protocol binaries
-  //
-  // Examples:
-  // {
-  //   "id": "server-1",
-  //   "executable": "/path",
-  //   "args": ['arg1", "args2"]
-  // }
-  "experimental.context_servers": {
-    "servers": []
-  }
+  "ssh_connections": null
 }

crates/anthropic/Cargo.toml

@@ -17,7 +17,6 @@ path = "src/anthropic.rs"
 
 [dependencies]
 anyhow.workspace = true
-chrono.workspace = true
 futures.workspace = true
 http_client.workspace = true
 isahc.workspace = true
@@ -25,8 +24,6 @@ schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
 strum.workspace = true
-thiserror.workspace = true
-util.workspace = true
 
 [dev-dependencies]
 tokio.workspace = true

crates/anthropic/src/anthropic.rs

@@ -1,53 +1,35 @@
 mod supported_countries;
 
-use anyhow::{anyhow, Context, Result};
-use chrono::{DateTime, Utc};
+use anyhow::{anyhow, Result};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use isahc::config::Configurable;
-use isahc::http::{HeaderMap, HeaderValue};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
-use std::{pin::Pin, str::FromStr};
-use strum::{EnumIter, EnumString};
-use thiserror::Error;
-use util::ResultExt as _;
+use strum::EnumIter;
 
 pub use supported_countries::*;
 
 pub const ANTHROPIC_API_URL: &'static str = "https://api.anthropic.com";
 
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
-pub struct AnthropicModelCacheConfiguration {
-    pub min_total_token: usize,
-    pub should_speculate: bool,
-    pub max_cache_anchors: usize,
-}
-
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
     #[default]
-    #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-20240620")]
+    #[serde(alias = "claude-3-5-sonnet", rename = "claude-3-5-sonnet-20240620")]
     Claude3_5Sonnet,
-    #[serde(rename = "claude-3-opus", alias = "claude-3-opus-20240229")]
+    #[serde(alias = "claude-3-opus", rename = "claude-3-opus-20240229")]
     Claude3Opus,
-    #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-20240229")]
+    #[serde(alias = "claude-3-sonnet", rename = "claude-3-sonnet-20240229")]
     Claude3Sonnet,
-    #[serde(rename = "claude-3-haiku", alias = "claude-3-haiku-20240307")]
+    #[serde(alias = "claude-3-haiku", rename = "claude-3-haiku-20240307")]
     Claude3Haiku,
     #[serde(rename = "custom")]
     Custom {
         name: String,
         max_tokens: usize,
-        /// The name displayed in the UI, such as in the assistant panel model dropdown menu.
-        display_name: Option<String>,
         /// Override this model with a different Anthropic model for tool calls.
         tool_override: Option<String>,
-        /// Indicates whether this custom model supports caching.
-        cache_configuration: Option<AnthropicModelCacheConfiguration>,
-        max_output_tokens: Option<u32>,
     },
 }
 
@@ -71,7 +53,7 @@ impl Model {
             Model::Claude3_5Sonnet => "claude-3-5-sonnet-20240620",
             Model::Claude3Opus => "claude-3-opus-20240229",
             Model::Claude3Sonnet => "claude-3-sonnet-20240229",
-            Model::Claude3Haiku => "claude-3-haiku-20240307",
+            Model::Claude3Haiku => "claude-3-opus-20240307",
             Self::Custom { name, .. } => name,
         }
     }
@@ -82,24 +64,7 @@ impl Model {
             Self::Claude3Opus => "Claude 3 Opus",
             Self::Claude3Sonnet => "Claude 3 Sonnet",
             Self::Claude3Haiku => "Claude 3 Haiku",
-            Self::Custom {
-                name, display_name, ..
-            } => display_name.as_ref().unwrap_or(name),
-        }
-    }
-
-    pub fn cache_configuration(&self) -> Option<AnthropicModelCacheConfiguration> {
-        match self {
-            Self::Claude3_5Sonnet | Self::Claude3Haiku => Some(AnthropicModelCacheConfiguration {
-                min_total_token: 2_048,
-                should_speculate: true,
-                max_cache_anchors: 4,
-            }),
-            Self::Custom {
-                cache_configuration,
-                ..
-            } => cache_configuration.clone(),
-            _ => None,
+            Self::Custom { name, .. } => name,
         }
     }
 
@@ -113,16 +78,6 @@ impl Model {
         }
     }
 
-    pub fn max_output_tokens(&self) -> u32 {
-        match self {
-            Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3Haiku => 4_096,
-            Self::Claude3_5Sonnet => 8_192,
-            Self::Custom {
-                max_output_tokens, ..
-            } => max_output_tokens.unwrap_or(4_096),
-        }
-    }
-
     pub fn tool_model_id(&self) -> &str {
         if let Self::Custom {
             tool_override: Some(tool_override),
@@ -141,53 +96,34 @@ pub async fn complete(
     api_url: &str,
     api_key: &str,
     request: Request,
-) -> Result<Response, AnthropicError> {
+) -> Result<Response> {
     let uri = format!("{api_url}/v1/messages");
     let request_builder = HttpRequest::builder()
         .method(Method::POST)
         .uri(uri)
         .header("Anthropic-Version", "2023-06-01")
-        .header(
-            "Anthropic-Beta",
-            "tools-2024-04-04,prompt-caching-2024-07-31,max-tokens-3-5-sonnet-2024-07-15",
-        )
+        .header("Anthropic-Beta", "tools-2024-04-04")
         .header("X-Api-Key", api_key)
         .header("Content-Type", "application/json");
 
-    let serialized_request =
-        serde_json::to_string(&request).context("failed to serialize request")?;
-    let request = request_builder
-        .body(AsyncBody::from(serialized_request))
-        .context("failed to construct request body")?;
+    let serialized_request = serde_json::to_string(&request)?;
+    let request = request_builder.body(AsyncBody::from(serialized_request))?;
 
-    let mut response = client
-        .send(request)
-        .await
-        .context("failed to send request to Anthropic")?;
+    let mut response = client.send(request).await?;
     if response.status().is_success() {
         let mut body = Vec::new();
-        response
-            .body_mut()
-            .read_to_end(&mut body)
-            .await
-            .context("failed to read response body")?;
-        let response_message: Response =
-            serde_json::from_slice(&body).context("failed to deserialize response body")?;
+        response.body_mut().read_to_end(&mut body).await?;
+        let response_message: Response = serde_json::from_slice(&body)?;
         Ok(response_message)
     } else {
         let mut body = Vec::new();
-        response
-            .body_mut()
-            .read_to_end(&mut body)
-            .await
-            .context("failed to read response body")?;
-        let body_str =
-            std::str::from_utf8(&body).context("failed to parse response body as UTF-8")?;
-        Err(AnthropicError::Other(anyhow!(
+        response.body_mut().read_to_end(&mut body).await?;
+        let body_str = std::str::from_utf8(&body)?;
+        Err(anyhow!(
             "Failed to connect to API: {} {}",
             response.status(),
             body_str
-        )))
+        ))
     }
 }
 
@@ -197,67 +133,7 @@ pub async fn stream_completion(
     api_key: &str,
     request: Request,
     low_speed_timeout: Option<Duration>,
-) -> Result<BoxStream<'static, Result<Event, AnthropicError>>, AnthropicError> {
-    stream_completion_with_rate_limit_info(client, api_url, api_key, request, low_speed_timeout)
-        .await
-        .map(|output| output.0)
-}
-
-/// https://docs.anthropic.com/en/api/rate-limits#response-headers
-#[derive(Debug)]
-pub struct RateLimitInfo {
-    pub requests_limit: usize,
-    pub requests_remaining: usize,
-    pub requests_reset: DateTime<Utc>,
-    pub tokens_limit: usize,
-    pub tokens_remaining: usize,
-    pub tokens_reset: DateTime<Utc>,
-}
-
-impl RateLimitInfo {
-    fn from_headers(headers: &HeaderMap<HeaderValue>) -> Result<Self> {
-        let tokens_limit = get_header("anthropic-ratelimit-tokens-limit", headers)?.parse()?;
-        let requests_limit = get_header("anthropic-ratelimit-requests-limit", headers)?.parse()?;
-        let tokens_remaining =
-            get_header("anthropic-ratelimit-tokens-remaining", headers)?.parse()?;
-        let requests_remaining =
-            get_header("anthropic-ratelimit-requests-remaining", headers)?.parse()?;
-        let requests_reset = get_header("anthropic-ratelimit-requests-reset", headers)?;
-        let tokens_reset = get_header("anthropic-ratelimit-tokens-reset", headers)?;
-        let requests_reset = DateTime::parse_from_rfc3339(requests_reset)?.to_utc();
-        let tokens_reset = DateTime::parse_from_rfc3339(tokens_reset)?.to_utc();
-
-        Ok(Self {
-            requests_limit,
-            tokens_limit,
-            requests_remaining,
-            tokens_remaining,
-            requests_reset,
-            tokens_reset,
-        })
-    }
-}
-
-fn get_header<'a>(key: &str, headers: &'a HeaderMap) -> Result<&'a str, anyhow::Error> {
-    Ok(headers
-        .get(key)
-        .ok_or_else(|| anyhow!("missing header `{key}`"))?
-        .to_str()?)
-}
-
-pub async fn stream_completion_with_rate_limit_info(
-    client: &dyn HttpClient,
-    api_url: &str,
-    api_key: &str,
-    request: Request,
-    low_speed_timeout: Option<Duration>,
-) -> Result<
-    (
-        BoxStream<'static, Result<Event, AnthropicError>>,
-        Option<RateLimitInfo>,
-    ),
-    AnthropicError,
-> {
+) -> Result<BoxStream<'static, Result<Event>>> {
     let request = StreamingRequest {
         base: request,
         stream: true,
@@ -267,29 +143,19 @@ pub async fn stream_completion_with_rate_limit_info(
         .method(Method::POST)
         .uri(uri)
         .header("Anthropic-Version", "2023-06-01")
-        .header(
-            "Anthropic-Beta",
-            "tools-2024-04-04,prompt-caching-2024-07-31,max-tokens-3-5-sonnet-2024-07-15",
-        )
+        .header("Anthropic-Beta", "tools-2024-04-04")
         .header("X-Api-Key", api_key)
         .header("Content-Type", "application/json");
     if let Some(low_speed_timeout) = low_speed_timeout {
         request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
     }
-    let serialized_request =
-        serde_json::to_string(&request).context("failed to serialize request")?;
-    let request = request_builder
-        .body(AsyncBody::from(serialized_request))
-        .context("failed to construct request body")?;
+    let serialized_request = serde_json::to_string(&request)?;
+    let request = request_builder.body(AsyncBody::from(serialized_request))?;
 
-    let mut response = client
-        .send(request)
-        .await
-        .context("failed to send request to Anthropic")?;
+    let mut response = client.send(request).await?;
     if response.status().is_success() {
-        let rate_limits = RateLimitInfo::from_headers(response.headers());
         let reader = BufReader::new(response.into_body());
-        let stream = reader
+        Ok(reader
             .lines()
             .filter_map(|line| async move {
                 match line {
@@ -297,54 +163,48 @@ pub async fn stream_completion_with_rate_limit_info(
                         let line = line.strip_prefix("data: ")?;
                         match serde_json::from_str(line) {
                             Ok(response) => Some(Ok(response)),
-                            Err(error) => Some(Err(AnthropicError::Other(anyhow!(error)))),
+                            Err(error) => Some(Err(anyhow!(error))),
                         }
                     }
-                    Err(error) => Some(Err(AnthropicError::Other(anyhow!(error)))),
+                    Err(error) => Some(Err(anyhow!(error))),
                 }
             })
-            .boxed();
-        Ok((stream, rate_limits.log_err()))
+            .boxed())
     } else {
         let mut body = Vec::new();
-        response
-            .body_mut()
-            .read_to_end(&mut body)
-            .await
-            .context("failed to read response body")?;
+        response.body_mut().read_to_end(&mut body).await?;
 
-        let body_str =
-            std::str::from_utf8(&body).context("failed to parse response body as UTF-8")?;
+        let body_str = std::str::from_utf8(&body)?;
 
         match serde_json::from_str::<Event>(body_str) {
-            Ok(Event::Error { error }) => Err(AnthropicError::ApiError(error)),
-            Ok(_) => Err(AnthropicError::Other(anyhow!(
+            Ok(Event::Error { error }) => Err(api_error_to_err(error)),
+            Ok(_) => Err(anyhow!(
                 "Unexpected success response while expecting an error: '{body_str}'",
-            ))),
-            Err(_) => Err(AnthropicError::Other(anyhow!(
+            )),
+            Err(_) => Err(anyhow!(
                 "Failed to connect to API: {} {}",
                 response.status(),
                 body_str,
-            ))),
+            )),
         }
     }
 }
 
 pub fn extract_text_from_events(
-    response: impl Stream<Item = Result<Event, AnthropicError>>,
-) -> impl Stream<Item = Result<String, AnthropicError>> {
+    response: impl Stream<Item = Result<Event>>,
+) -> impl Stream<Item = Result<String>> {
     response.filter_map(|response| async move {
         match response {
             Ok(response) => match response {
                 Event::ContentBlockStart { content_block, .. } => match content_block {
-                    Content::Text { text, .. } => Some(Ok(text)),
+                    Content::Text { text } => Some(Ok(text)),
                     _ => None,
                 },
                 Event::ContentBlockDelta { delta, .. } => match delta {
                     ContentDelta::TextDelta { text } => Some(Ok(text)),
                     _ => None,
                 },
-                Event::Error { error } => Some(Err(AnthropicError::ApiError(error))),
+                Event::Error { error } => Some(Err(api_error_to_err(error))),
                 _ => None,
             },
             Err(error) => Some(Err(error)),
@@ -352,60 +212,13 @@ pub fn extract_text_from_events(
     })
 }
 
-pub async fn extract_tool_args_from_events(
-    tool_name: String,
-    mut events: Pin<Box<dyn Send + Stream<Item = Result<Event>>>>,
-) -> Result<impl Send + Stream<Item = Result<String>>> {
-    let mut tool_use_index = None;
-    while let Some(event) = events.next().await {
-        if let Event::ContentBlockStart {
-            index,
-            content_block,
-        } = event?
-        {
-            if let Content::ToolUse { name, .. } = content_block {
-                if name == tool_name {
-                    tool_use_index = Some(index);
-                    break;
-                }
-            }
-        }
-    }
-
-    let Some(tool_use_index) = tool_use_index else {
-        return Err(anyhow!("tool not used"));
-    };
-
-    Ok(events.filter_map(move |event| {
-        let result = match event {
-            Err(error) => Some(Err(error)),
-            Ok(Event::ContentBlockDelta { index, delta }) => match delta {
-                ContentDelta::TextDelta { .. } => None,
-                ContentDelta::InputJsonDelta { partial_json } => {
-                    if index == tool_use_index {
-                        Some(Ok(partial_json))
-                    } else {
-                        None
-                    }
-                }
-            },
-            _ => None,
-        };
-
-        async move { result }
-    }))
-}
-
-#[derive(Debug, Serialize, Deserialize, Copy, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum CacheControlType {
-    Ephemeral,
-}
-
-#[derive(Debug, Serialize, Deserialize, Copy, Clone)]
-pub struct CacheControl {
-    #[serde(rename = "type")]
-    pub cache_type: CacheControlType,
+fn api_error_to_err(
+    ApiError {
+        error_type,
+        message,
+    }: ApiError,
+) -> anyhow::Error {
+    anyhow!("API error. Type: '{error_type}', message: '{message}'",)
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -414,7 +227,7 @@ pub struct Message {
     pub content: Vec<Content>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Hash)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum Role {
     User,
@@ -425,31 +238,19 @@ pub enum Role {
 #[serde(tag = "type")]
 pub enum Content {
     #[serde(rename = "text")]
-    Text {
-        text: String,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        cache_control: Option<CacheControl>,
-    },
+    Text { text: String },
     #[serde(rename = "image")]
-    Image {
-        source: ImageSource,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        cache_control: Option<CacheControl>,
-    },
+    Image { source: ImageSource },
     #[serde(rename = "tool_use")]
     ToolUse {
         id: String,
         name: String,
         input: serde_json::Value,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        cache_control: Option<CacheControl>,
     },
     #[serde(rename = "tool_result")]
     ToolResult {
         tool_use_id: String,
         content: String,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        cache_control: Option<CacheControl>,
     },
 }
 
@@ -573,53 +374,9 @@ pub struct MessageDelta {
     pub stop_sequence: Option<String>,
 }
 
-#[derive(Error, Debug)]
-pub enum AnthropicError {
-    #[error("an error occurred while interacting with the Anthropic API: {error_type}: {message}", error_type = .0.error_type, message = .0.message)]
-    ApiError(ApiError),
-    #[error("{0}")]
-    Other(#[from] anyhow::Error),
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ApiError {
     #[serde(rename = "type")]
     pub error_type: String,
     pub message: String,
 }
-
-/// An Anthropic API error code.
-/// https://docs.anthropic.com/en/api/errors#http-errors
-#[derive(Debug, PartialEq, Eq, Clone, Copy, EnumString)]
-#[strum(serialize_all = "snake_case")]
-pub enum ApiErrorCode {
-    /// 400 - `invalid_request_error`: There was an issue with the format or content of your request.
-    InvalidRequestError,
-    /// 401 - `authentication_error`: There's an issue with your API key.
-    AuthenticationError,
-    /// 403 - `permission_error`: Your API key does not have permission to use the specified resource.
-    PermissionError,
-    /// 404 - `not_found_error`: The requested resource was not found.
-    NotFoundError,
-    /// 413 - `request_too_large`: Request exceeds the maximum allowed number of bytes.
-    RequestTooLarge,
-    /// 429 - `rate_limit_error`: Your account has hit a rate limit.
-    RateLimitError,
-    /// 500 - `api_error`: An unexpected error has occurred internal to Anthropic's systems.
-    ApiError,
-    /// 529 - `overloaded_error`: Anthropic's API is temporarily overloaded.
-    OverloadedError,
-}
-
-impl ApiError {
-    pub fn code(&self) -> Option<ApiErrorCode> {
-        ApiErrorCode::from_str(&self.error_type).ok()
-    }
-
-    pub fn is_rate_limit_error(&self) -> bool {
-        match self.error_type.as_str() {
-            "rate_limit_error" => true,
-            _ => false,
-        }
-    }
-}

crates/assistant/Cargo.toml

@@ -33,13 +33,11 @@ clock.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 db.workspace = true
-context_servers.workspace = true
 editor.workspace = true
 feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
-globset.workspace = true
 gpui.workspace = true
 handlebars.workspace = true
 heed.workspace = true
@@ -68,8 +66,6 @@ semantic_index.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
-smallvec.workspace = true
-similar.workspace = true
 smol.workspace = true
 telemetry_events.workspace = true
 terminal.workspace = true

crates/assistant/src/assistant.rs

@@ -1,5 +1,3 @@
-#![cfg_attr(target_os = "windows", allow(unused, dead_code))]
-
 pub mod assistant_panel;
 pub mod assistant_settings;
 mod context;
@@ -9,11 +7,8 @@ mod model_selector;
 mod prompt_library;
 mod prompts;
 mod slash_command;
-pub(crate) mod slash_command_picker;
-pub mod slash_command_settings;
 mod streaming_diff;
 mod terminal_inline_assistant;
-mod workflow;
 
 pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
 use assistant_settings::AssistantSettings;
@@ -21,11 +16,8 @@ use assistant_slash_command::SlashCommandRegistry;
 use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
 pub use context::*;
-use context_servers::ContextServerRegistry;
 pub use context_store::*;
-use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
-use gpui::Context as _;
 use gpui::{actions, impl_actions, AppContext, Global, SharedString, UpdateGlobal};
 use indexed_docs::IndexedDocsRegistry;
 pub(crate) use inline_assistant::*;
@@ -34,21 +26,17 @@ use language_model::{
 };
 pub(crate) use model_selector::*;
 pub use prompts::PromptBuilder;
-use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticIndex};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
 use slash_command::{
-    context_server_command, default_command, diagnostics_command, docs_command, fetch_command,
+    active_command, default_command, diagnostics_command, docs_command, fetch_command,
     file_command, now_command, project_command, prompt_command, search_command, symbols_command,
-    tab_command, terminal_command, workflow_command,
+    tabs_command, term_command, workflow_command,
 };
 use std::sync::Arc;
 pub(crate) use streaming_diff::*;
 use util::ResultExt;
-pub use workflow::*;
-
-use crate::slash_command_settings::SlashCommandSettings;
 
 actions!(
     assistant,
@@ -60,14 +48,16 @@ actions!(
         InsertIntoEditor,
         ToggleFocus,
         InsertActivePrompt,
+        ShowConfiguration,
         DeployHistory,
         DeployPromptLibrary,
         ConfirmCommand,
         ToggleModelSelector,
+        DebugEditSteps
     ]
 );
 
-const DEFAULT_CONTEXT_LINES: usize = 50;
+const DEFAULT_CONTEXT_LINES: usize = 20;
 
 #[derive(Clone, Default, Deserialize, PartialEq)]
 pub struct InlineAssist {
@@ -104,7 +94,6 @@ pub enum MessageStatus {
     Pending,
     Done,
     Error(SharedString),
-    Canceled,
 }
 
 impl MessageStatus {
@@ -115,7 +104,6 @@ impl MessageStatus {
             Some(proto::context_message_status::Variant::Error(error)) => {
                 MessageStatus::Error(error.message.into())
             }
-            Some(proto::context_message_status::Variant::Canceled(_)) => MessageStatus::Canceled,
             None => MessageStatus::Pending,
         }
     }
@@ -139,11 +127,6 @@ impl MessageStatus {
                     },
                 )),
             },
-            MessageStatus::Canceled => proto::ContextMessageStatus {
-                variant: Some(proto::context_message_status::Variant::Canceled(
-                    proto::context_message_status::Canceled {},
-                )),
-            },
         }
     }
 }
@@ -181,15 +164,9 @@ impl Assistant {
     }
 }
 
-pub fn init(
-    fs: Arc<dyn Fs>,
-    client: Arc<Client>,
-    stdout_is_a_pty: bool,
-    cx: &mut AppContext,
-) -> Arc<PromptBuilder> {
+pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, cx: &mut AppContext) -> Arc<PromptBuilder> {
     cx.set_global(Assistant::default());
     AssistantSettings::register(cx);
-    SlashCommandSettings::register(cx);
 
     // TODO: remove this when 0.148.0 is released.
     if AssistantSettings::get_global(cx).using_outdated_settings_version {
@@ -221,18 +198,11 @@ pub fn init(
     init_language_model_settings(cx);
     assistant_slash_command::init(cx);
     assistant_panel::init(cx);
-    context_servers::init(cx);
 
-    let prompt_builder = prompts::PromptBuilder::new(Some(PromptLoadingParams {
-        fs: fs.clone(),
-        repo_path: stdout_is_a_pty
-            .then(|| std::env::current_dir().log_err())
-            .flatten(),
-        cx,
-    }))
-    .log_err()
-    .map(Arc::new)
-    .unwrap_or_else(|| Arc::new(prompts::PromptBuilder::new(None).unwrap()));
+    let prompt_builder = prompts::PromptBuilder::new(Some((fs.clone(), cx)))
+        .log_err()
+        .map(Arc::new)
+        .unwrap_or_else(|| Arc::new(prompts::PromptBuilder::new(None).unwrap()));
     register_slash_commands(Some(prompt_builder.clone()), cx);
     inline_assistant::init(
         fs.clone(),
@@ -264,69 +234,9 @@ pub fn init(
     })
     .detach();
 
-    register_context_server_handlers(cx);
-
     prompt_builder
 }
 
-fn register_context_server_handlers(cx: &mut AppContext) {
-    cx.subscribe(
-        &context_servers::manager::ContextServerManager::global(cx),
-        |manager, event, cx| match event {
-            context_servers::manager::Event::ServerStarted { server_id } => {
-                cx.update_model(
-                    &manager,
-                    |manager: &mut context_servers::manager::ContextServerManager, cx| {
-                        let slash_command_registry = SlashCommandRegistry::global(cx);
-                        let context_server_registry = ContextServerRegistry::global(cx);
-                        if let Some(server) = manager.get_server(server_id) {
-                            cx.spawn(|_, _| async move {
-                                let Some(protocol) = server.client.read().clone() else {
-                                    return;
-                                };
-
-                                if let Some(prompts) = protocol.list_prompts().await.log_err() {
-                                    for prompt in prompts
-                                        .into_iter()
-                                        .filter(context_server_command::acceptable_prompt)
-                                    {
-                                        log::info!(
-                                            "registering context server command: {:?}",
-                                            prompt.name
-                                        );
-                                        context_server_registry.register_command(
-                                            server.id.clone(),
-                                            prompt.name.as_str(),
-                                        );
-                                        slash_command_registry.register_command(
-                                            context_server_command::ContextServerSlashCommand::new(
-                                                &server, prompt,
-                                            ),
-                                            true,
-                                        );
-                                    }
-                                }
-                            })
-                            .detach();
-                        }
-                    },
-                );
-            }
-            context_servers::manager::Event::ServerStopped { server_id } => {
-                let slash_command_registry = SlashCommandRegistry::global(cx);
-                let context_server_registry = ContextServerRegistry::global(cx);
-                if let Some(commands) = context_server_registry.get_commands(server_id) {
-                    for command_name in commands {
-                        slash_command_registry.unregister_command_by_name(&command_name);
-                        context_server_registry.unregister_command(&server_id, &command_name);
-                    }
-                }
-            }
-        },
-    )
-    .detach();
-}
-
 fn init_language_model_settings(cx: &mut AppContext) {
     update_active_language_model_from_settings(cx);
 
@@ -358,15 +268,17 @@ fn update_active_language_model_from_settings(cx: &mut AppContext) {
 fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut AppContext) {
     let slash_command_registry = SlashCommandRegistry::global(cx);
     slash_command_registry.register_command(file_command::FileSlashCommand, true);
+    slash_command_registry.register_command(active_command::ActiveSlashCommand, true);
     slash_command_registry.register_command(symbols_command::OutlineSlashCommand, true);
-    slash_command_registry.register_command(tab_command::TabSlashCommand, true);
+    slash_command_registry.register_command(tabs_command::TabsSlashCommand, true);
     slash_command_registry.register_command(project_command::ProjectSlashCommand, true);
+    slash_command_registry.register_command(search_command::SearchSlashCommand, true);
     slash_command_registry.register_command(prompt_command::PromptSlashCommand, true);
-    slash_command_registry.register_command(default_command::DefaultSlashCommand, false);
-    slash_command_registry.register_command(terminal_command::TerminalSlashCommand, true);
-    slash_command_registry.register_command(now_command::NowSlashCommand, false);
+    slash_command_registry.register_command(default_command::DefaultSlashCommand, true);
+    slash_command_registry.register_command(term_command::TermSlashCommand, true);
+    slash_command_registry.register_command(now_command::NowSlashCommand, true);
     slash_command_registry.register_command(diagnostics_command::DiagnosticsSlashCommand, true);
-
+    slash_command_registry.register_command(docs_command::DocsSlashCommand, true);
     if let Some(prompt_builder) = prompt_builder {
         slash_command_registry.register_command(
             workflow_command::WorkflowSlashCommand::new(prompt_builder),
@@ -374,37 +286,6 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
         );
     }
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
-
-    update_slash_commands_from_settings(cx);
-    cx.observe_global::<SettingsStore>(update_slash_commands_from_settings)
-        .detach();
-
-    cx.observe_flag::<search_command::SearchSlashCommandFeatureFlag, _>({
-        let slash_command_registry = slash_command_registry.clone();
-        move |is_enabled, _cx| {
-            if is_enabled {
-                slash_command_registry.register_command(search_command::SearchSlashCommand, true);
-            }
-        }
-    })
-    .detach();
-}
-
-fn update_slash_commands_from_settings(cx: &mut AppContext) {
-    let slash_command_registry = SlashCommandRegistry::global(cx);
-    let settings = SlashCommandSettings::get_global(cx);
-
-    if settings.docs.enabled {
-        slash_command_registry.register_command(docs_command::DocsSlashCommand, true);
-    } else {
-        slash_command_registry.unregister_command(docs_command::DocsSlashCommand);
-    }
-
-    if settings.project.enabled {
-        slash_command_registry.register_command(project_command::ProjectSlashCommand, true);
-    } else {
-        slash_command_registry.unregister_command(project_command::ProjectSlashCommand);
-    }
 }
 
 pub fn humanize_token_count(count: usize) -> String {

crates/assistant/src/assistant_settings.rs

@@ -543,8 +543,8 @@ mod tests {
             assert_eq!(
                 AssistantSettings::get_global(cx).default_model,
                 LanguageModelSelection {
-                    provider: "zed.dev".into(),
-                    model: "claude-3-5-sonnet".into(),
+                    provider: "openai".into(),
+                    model: "gpt-4o".into(),
                 }
             );
         });

crates/assistant/src/inline_assistant.rs

@@ -19,7 +19,6 @@ use fs::Fs;
 use futures::{
     channel::mpsc,
     future::{BoxFuture, LocalBoxFuture},
-    join,
     stream::{self, BoxStream},
     SinkExt, Stream, StreamExt,
 };
@@ -59,13 +58,6 @@ pub fn init(
     cx: &mut AppContext,
 ) {
     cx.set_global(InlineAssistant::new(fs, prompt_builder, telemetry));
-    cx.observe_new_views(|_, cx| {
-        let workspace = cx.view().clone();
-        InlineAssistant::update_global(cx, |inline_assistant, cx| {
-            inline_assistant.register_workspace(&workspace, cx)
-        })
-    })
-    .detach();
 }
 
 const PROMPT_HISTORY_MAX_LEN: usize = 20;
@@ -76,33 +68,12 @@ 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<Codegen>>,
     prompt_history: VecDeque<String>,
     prompt_builder: Arc<PromptBuilder>,
     telemetry: Option<Arc<Telemetry>>,
     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 {
@@ -117,8 +88,6 @@ 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,
             telemetry: Some(telemetry),
@@ -126,29 +95,6 @@ impl InlineAssistant {
         }
     }
 
-    pub fn register_workspace(&mut self, workspace: &View<Workspace>, cx: &mut WindowContext) {
-        cx.subscribe(workspace, |_, event, cx| {
-            Self::update_global(cx, |this, cx| this.handle_workspace_event(event, cx));
-        })
-        .detach();
-    }
-
-    fn handle_workspace_event(&mut self, event: &workspace::Event, cx: &mut WindowContext) {
-        // When the user manually saves an editor, automatically accepts all finished transformations.
-        if let workspace::Event::UserSavedItem { item, .. } = event {
-            if let Some(editor) = item.upgrade().and_then(|item| item.act_as::<Editor>(cx)) {
-                if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
-                    for assist_id in editor_assists.assist_ids.clone() {
-                        let assist = &self.assists[&assist_id];
-                        if let CodegenStatus::Done = &assist.codegen.read(cx).status {
-                            self.finish_assist(assist_id, false, cx)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
     pub fn assist(
         &mut self,
         editor: &View<Editor>,
@@ -397,7 +343,6 @@ impl InlineAssistant {
                 height: prompt_editor_height,
                 render: build_assist_editor_renderer(prompt_editor),
                 disposition: BlockDisposition::Above,
-                priority: 0,
             },
             BlockProperties {
                 style: BlockStyle::Sticky,
@@ -412,7 +357,6 @@ impl InlineAssistant {
                         .into_any_element()
                 }),
                 disposition: BlockDisposition::Below,
-                priority: 0,
             },
         ];
 
@@ -547,43 +491,17 @@ impl InlineAssistant {
         if editor.selections.count() == 1 {
             let selection = editor.selections.newest::<usize>(cx);
             let buffer = editor.buffer().read(cx).snapshot(cx);
-            let mut closest_assist_fallback = None;
             for assist_id in &editor_assists.assist_ids {
                 let assist = &self.assists[assist_id];
                 let assist_range = assist.range.to_offset(&buffer);
-                if assist.decorations.is_some() {
-                    if assist_range.contains(&selection.start)
-                        && assist_range.contains(&selection.end)
-                    {
-                        self.focus_assist(*assist_id, cx);
-                        return;
-                    } else {
-                        let distance_from_selection = assist_range
-                            .start
-                            .abs_diff(selection.start)
-                            .min(assist_range.start.abs_diff(selection.end))
-                            + assist_range
-                                .end
-                                .abs_diff(selection.start)
-                                .min(assist_range.end.abs_diff(selection.end));
-                        match closest_assist_fallback {
-                            Some((_, old_distance)) => {
-                                if distance_from_selection < old_distance {
-                                    closest_assist_fallback =
-                                        Some((assist_id, distance_from_selection));
-                                }
-                            }
-                            None => {
-                                closest_assist_fallback = Some((assist_id, distance_from_selection))
-                            }
-                        }
-                    }
+                if assist.decorations.is_some()
+                    && assist_range.contains(&selection.start)
+                    && assist_range.contains(&selection.end)
+                {
+                    self.focus_assist(*assist_id, cx);
+                    return;
                 }
             }
-
-            if let Some((&assist_id, _)) = closest_assist_fallback {
-                self.focus_assist(assist_id, cx);
-            }
         }
 
         cx.propagate();
@@ -633,6 +551,14 @@ impl InlineAssistant {
         };
 
         match event {
+            EditorEvent::Saved => {
+                for assist_id in editor_assists.assist_ids.clone() {
+                    let assist = &self.assists[&assist_id];
+                    if let CodegenStatus::Done = &assist.codegen.read(cx).status {
+                        self.finish_assist(assist_id, false, cx)
+                    }
+                }
+            }
             EditorEvent::Edited { transaction_id } => {
                 let buffer = editor.read(cx).buffer().read(cx);
                 let edited_ranges =
@@ -728,21 +654,8 @@ impl InlineAssistant {
 
             if undo {
                 assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
-            } else {
-                self.confirmed_assists.insert(assist_id, assist.codegen);
             }
         }
-
-        // 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 {
@@ -941,10 +854,6 @@ impl InlineAssistant {
                 )
             })
             .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) {
@@ -955,24 +864,19 @@ 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 {
-                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
+    pub fn status_for_assist(
+        &self,
+        assist_id: InlineAssistId,
+        cx: &WindowContext,
+    ) -> Option<CodegenStatus> {
+        let assist = self.assists.get(&assist_id)?;
+        match &assist.codegen.read(cx).status {
+            CodegenStatus::Idle => Some(CodegenStatus::Idle),
+            CodegenStatus::Pending => Some(CodegenStatus::Pending),
+            CodegenStatus::Done => Some(CodegenStatus::Done),
+            CodegenStatus::Error(error) => Some(CodegenStatus::Error(anyhow!("{:?}", error))),
         }
     }
 
@@ -1122,7 +1026,6 @@ impl InlineAssistant {
                     editor.set_show_gutter(false, cx);
                     editor.scroll_manager.set_forbid_vertical_scroll(true);
                     editor.set_read_only(true);
-                    editor.set_show_inline_completions(false);
                     editor.highlight_rows::<DeletedLines>(
                         Anchor::min()..=Anchor::max(),
                         Some(cx.theme().status().deleted_background),
@@ -1148,7 +1051,6 @@ impl InlineAssistant {
                             .into_any_element()
                     }),
                     disposition: BlockDisposition::Above,
-                    priority: 0,
                 });
             }
 
@@ -1158,40 +1060,6 @@ 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 {
@@ -1299,6 +1167,12 @@ fn build_assist_editor_renderer(editor: &View<PromptEditor>) -> RenderBlock {
     })
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum InitialInsertion {
+    NewlineBefore,
+    NewlineAfter,
+}
+
 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
 pub struct InlineAssistId(usize);
 
@@ -1342,18 +1216,12 @@ struct PromptEditor {
     _codegen_subscription: Subscription,
     editor_subscriptions: Vec<Subscription>,
     pending_token_count: Task<Result<()>>,
-    token_counts: Option<TokenCounts>,
+    token_count: Option<usize>,
     _token_count_subscriptions: Vec<Subscription>,
     workspace: Option<WeakView<Workspace>>,
     show_rate_limit_notice: bool,
 }
 
-#[derive(Copy, Clone)]
-pub struct TokenCounts {
-    total: usize,
-    assistant_panel: usize,
-}
-
 impl EventEmitter<PromptEditorEvent> for PromptEditor {}
 
 impl Render for PromptEditor {
@@ -1599,7 +1467,7 @@ impl PromptEditor {
             codegen,
             fs,
             pending_token_count: Task::ready(Ok(())),
-            token_counts: None,
+            token_count: None,
             _token_count_subscriptions: token_count_subscriptions,
             workspace,
             show_rate_limit_notice: false,
@@ -1689,7 +1557,7 @@ impl PromptEditor {
                 .await?;
 
             this.update(&mut cx, |this, cx| {
-                this.token_counts = Some(token_count);
+                this.token_count = Some(token_count);
                 cx.notify();
             })
         })
@@ -1830,13 +1698,13 @@ impl PromptEditor {
 
     fn render_token_count(&self, cx: &mut ViewContext<Self>) -> Option<impl IntoElement> {
         let model = LanguageModelRegistry::read_global(cx).active_model()?;
-        let token_counts = self.token_counts?;
+        let token_count = self.token_count?;
         let max_token_count = model.max_token_count();
 
-        let remaining_tokens = max_token_count as isize - token_counts.total as isize;
+        let remaining_tokens = max_token_count as isize - token_count as isize;
         let token_count_color = if remaining_tokens <= 0 {
             Color::Error
-        } else if token_counts.total as f32 / max_token_count as f32 >= 0.8 {
+        } else if token_count as f32 / max_token_count as f32 >= 0.8 {
             Color::Warning
         } else {
             Color::Muted
@@ -1846,7 +1714,7 @@ impl PromptEditor {
             .id("token_count")
             .gap_0p5()
             .child(
-                Label::new(humanize_token_count(token_counts.total))
+                Label::new(humanize_token_count(token_count))
                     .size(LabelSize::Small)
                     .color(token_count_color),
             )
@@ -1858,14 +1726,11 @@ impl PromptEditor {
             );
         if let Some(workspace) = self.workspace.clone() {
             token_count = token_count
-                .tooltip(move |cx| {
+                .tooltip(|cx| {
                     Tooltip::with_meta(
-                        format!(
-                            "Tokens Used ({} from the Assistant Panel)",
-                            humanize_token_count(token_counts.assistant_panel)
-                        ),
+                        "Tokens Used by Inline Assistant",
                         None,
-                        "Click to open the Assistant Panel",
+                        "Click to Open Assistant Panel",
                         cx,
                     )
                 })
@@ -1882,7 +1747,7 @@ impl PromptEditor {
         } else {
             token_count = token_count
                 .cursor_default()
-                .tooltip(|cx| Tooltip::text("Tokens used", cx));
+                .tooltip(|cx| Tooltip::text("Tokens Used by Inline Assistant", cx));
         }
 
         Some(token_count)
@@ -2099,8 +1964,6 @@ 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();
                             }
                         }
                     })
@@ -2131,7 +1994,7 @@ impl InlineAssist {
         }
     }
 
-    pub fn count_tokens(&self, cx: &WindowContext) -> BoxFuture<'static, Result<TokenCounts>> {
+    pub fn count_tokens(&self, cx: &WindowContext) -> BoxFuture<'static, Result<usize>> {
         let Some(user_prompt) = self.user_prompt(cx) else {
             return future::ready(Err(anyhow!("no user prompt"))).boxed();
         };
@@ -2174,7 +2037,7 @@ pub struct Codegen {
     builder: Arc<PromptBuilder>,
 }
 
-enum CodegenStatus {
+pub enum CodegenStatus {
     Idle,
     Pending,
     Done,
@@ -2268,25 +2131,11 @@ impl Codegen {
         user_prompt: String,
         assistant_panel_context: Option<LanguageModelRequest>,
         cx: &AppContext,
-    ) -> BoxFuture<'static, Result<TokenCounts>> {
+    ) -> BoxFuture<'static, Result<usize>> {
         if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-            let request =
-                self.build_request(user_prompt, assistant_panel_context.clone(), edit_range, cx);
+            let request = self.build_request(user_prompt, assistant_panel_context, edit_range, cx);
             match request {
-                Ok(request) => {
-                    let total_count = model.count_tokens(request.clone(), cx);
-                    let assistant_panel_count = assistant_panel_context
-                        .map(|context| model.count_tokens(context, cx))
-                        .unwrap_or_else(|| future::ready(Ok(0)).boxed());
-
-                    async move {
-                        Ok(TokenCounts {
-                            total: total_count.await?,
-                            assistant_panel: assistant_panel_count.await?,
-                        })
-                    }
-                    .boxed()
-                }
+                Ok(request) => model.count_tokens(request, cx),
                 Err(error) => futures::future::ready(Err(error)).boxed(),
             }
         } else {
@@ -2307,7 +2156,7 @@ impl Codegen {
 
         if let Some(transformation_transaction_id) = self.transformation_transaction_id.take() {
             self.buffer.update(cx, |buffer, cx| {
-                buffer.undo_transaction(transformation_transaction_id, cx);
+                buffer.undo_transaction(transformation_transaction_id, cx)
             });
         }
 
@@ -2378,7 +2227,6 @@ impl Codegen {
         } else {
             return Err(anyhow::anyhow!("invalid transformation range"));
         };
-
         let prompt = self
             .builder
             .generate_content_prompt(user_prompt, language_name, buffer, range)
@@ -2391,8 +2239,7 @@ impl Codegen {
 
         messages.push(LanguageModelRequestMessage {
             role: Role::User,
-            content: vec![prompt.into()],
-            cache: false,
+            content: prompt,
         });
 
         Ok(LanguageModelRequest {
@@ -2439,12 +2286,12 @@ impl Codegen {
         self.diff = Diff::default();
         self.status = CodegenStatus::Pending;
         let mut edit_start = edit_range.start.to_offset(&snapshot);
-        self.generation = cx.spawn(|codegen, mut cx| {
+        self.generation = cx.spawn(|this, mut cx| {
             async move {
                 let chunks = stream.await;
                 let generate = async {
                     let (mut diff_tx, mut diff_rx) = mpsc::channel(1);
-                    let line_based_stream_diff: Task<anyhow::Result<()>> =
+                    let diff: Task<anyhow::Result<()>> =
                         cx.background_executor().spawn(async move {
                             let mut response_latency = None;
                             let request_start = Instant::now();
@@ -2560,10 +2407,10 @@ impl Codegen {
                         });
 
                     while let Some((char_ops, line_diff)) = diff_rx.next().await {
-                        codegen.update(&mut cx, |codegen, cx| {
-                            codegen.last_equal_ranges.clear();
+                        this.update(&mut cx, |this, cx| {
+                            this.last_equal_ranges.clear();
 
-                            let transaction = codegen.buffer.update(cx, |buffer, cx| {
+                            let transaction = this.buffer.update(cx, |buffer, cx| {
                                 // Avoid grouping assistant edits with user edits.
                                 buffer.finalize_last_transaction(cx);
 
@@ -2588,24 +2435,23 @@ impl Codegen {
                                                 let edit_range = snapshot.anchor_after(edit_start)
                                                     ..snapshot.anchor_before(edit_end);
                                                 edit_start = edit_end;
-                                                codegen.last_equal_ranges.push(edit_range);
+                                                this.last_equal_ranges.push(edit_range);
                                                 None
                                             }
                                         }),
                                     None,
                                     cx,
                                 );
-                                codegen.edit_position = Some(snapshot.anchor_after(edit_start));
+                                this.edit_position = Some(snapshot.anchor_after(edit_start));
 
                                 buffer.end_transaction(cx)
                             });
 
                             if let Some(transaction) = transaction {
-                                if let Some(first_transaction) =
-                                    codegen.transformation_transaction_id
+                                if let Some(first_transaction) = this.transformation_transaction_id
                                 {
                                     // Group all assistant edits into the first transaction.
-                                    codegen.buffer.update(cx, |buffer, cx| {
+                                    this.buffer.update(cx, |buffer, cx| {
                                         buffer.merge_transactions(
                                             transaction,
                                             first_transaction,
@@ -2613,45 +2459,36 @@ impl Codegen {
                                         )
                                     });
                                 } else {
-                                    codegen.transformation_transaction_id = Some(transaction);
-                                    codegen.buffer.update(cx, |buffer, cx| {
+                                    this.transformation_transaction_id = Some(transaction);
+                                    this.buffer.update(cx, |buffer, cx| {
                                         buffer.finalize_last_transaction(cx)
                                     });
                                 }
                             }
 
-                            codegen.reapply_line_based_diff(edit_range.clone(), line_diff, cx);
+                            this.update_diff(edit_range.clone(), line_diff, cx);
 
                             cx.notify();
                         })?;
                     }
 
-                    // Streaming stopped and we have the new text in the buffer, and a line-based diff applied for the whole new buffer.
-                    // That diff is not what a regular diff is and might look unexpected, ergo apply a regular diff.
-                    // It's fine to apply even if the rest of the line diffing fails, as no more hunks are coming through `diff_rx`.
-                    let batch_diff_task = codegen.update(&mut cx, |codegen, cx| {
-                        codegen.reapply_batch_diff(edit_range.clone(), cx)
-                    })?;
-                    let (line_based_stream_diff, ()) =
-                        join!(line_based_stream_diff, batch_diff_task);
-                    line_based_stream_diff?;
+                    diff.await?;
 
                     anyhow::Ok(())
                 };
 
                 let result = generate.await;
-                codegen
-                    .update(&mut cx, |this, cx| {
-                        this.last_equal_ranges.clear();
-                        if let Err(error) = result {
-                            this.status = CodegenStatus::Error(error);
-                        } else {
-                            this.status = CodegenStatus::Done;
-                        }
-                        cx.emit(CodegenEvent::Finished);
-                        cx.notify();
-                    })
-                    .ok();
+                this.update(&mut cx, |this, cx| {
+                    this.last_equal_ranges.clear();
+                    if let Err(error) = result {
+                        this.status = CodegenStatus::Error(error);
+                    } else {
+                        this.status = CodegenStatus::Done;
+                    }
+                    cx.emit(CodegenEvent::Finished);
+                    cx.notify();
+                })
+                .ok();
             }
         });
         cx.notify();
@@ -2673,17 +2510,15 @@ impl Codegen {
         self.buffer.update(cx, |buffer, cx| {
             if let Some(transaction_id) = self.transformation_transaction_id.take() {
                 buffer.undo_transaction(transaction_id, cx);
-                buffer.refresh_preview(cx);
             }
 
             if let Some(transaction_id) = self.initial_transaction_id.take() {
                 buffer.undo_transaction(transaction_id, cx);
-                buffer.refresh_preview(cx);
             }
         });
     }
 
-    fn reapply_line_based_diff(
+    fn update_diff(
         &mut self,
         edit_range: Range<Anchor>,
         line_operations: Vec<LineOperation>,
@@ -2742,99 +2577,6 @@ impl Codegen {
             cx.notify();
         }
     }
-
-    fn reapply_batch_diff(
-        &mut self,
-        edit_range: Range<Anchor>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<()> {
-        let old_snapshot = self.snapshot.clone();
-        let old_range = edit_range.to_point(&old_snapshot);
-        let new_snapshot = self.buffer.read(cx).snapshot(cx);
-        let new_range = edit_range.to_point(&new_snapshot);
-
-        cx.spawn(|codegen, mut cx| async move {
-            let (deleted_row_ranges, inserted_row_ranges) = cx
-                .background_executor()
-                .spawn(async move {
-                    let old_text = old_snapshot
-                        .text_for_range(
-                            Point::new(old_range.start.row, 0)
-                                ..Point::new(
-                                    old_range.end.row,
-                                    old_snapshot.line_len(MultiBufferRow(old_range.end.row)),
-                                ),
-                        )
-                        .collect::<String>();
-                    let new_text = new_snapshot
-                        .text_for_range(
-                            Point::new(new_range.start.row, 0)
-                                ..Point::new(
-                                    new_range.end.row,
-                                    new_snapshot.line_len(MultiBufferRow(new_range.end.row)),
-                                ),
-                        )
-                        .collect::<String>();
-
-                    let mut old_row = old_range.start.row;
-                    let mut new_row = new_range.start.row;
-                    let batch_diff =
-                        similar::TextDiff::from_lines(old_text.as_str(), new_text.as_str());
-
-                    let mut deleted_row_ranges: Vec<(Anchor, RangeInclusive<u32>)> = Vec::new();
-                    let mut inserted_row_ranges = Vec::new();
-                    for change in batch_diff.iter_all_changes() {
-                        let line_count = change.value().lines().count() as u32;
-                        match change.tag() {
-                            similar::ChangeTag::Equal => {
-                                old_row += line_count;
-                                new_row += line_count;
-                            }
-                            similar::ChangeTag::Delete => {
-                                let old_end_row = old_row + line_count - 1;
-                                let new_row = new_snapshot.anchor_before(Point::new(new_row, 0));
-
-                                if let Some((_, last_deleted_row_range)) =
-                                    deleted_row_ranges.last_mut()
-                                {
-                                    if *last_deleted_row_range.end() + 1 == old_row {
-                                        *last_deleted_row_range =
-                                            *last_deleted_row_range.start()..=old_end_row;
-                                    } else {
-                                        deleted_row_ranges.push((new_row, old_row..=old_end_row));
-                                    }
-                                } else {
-                                    deleted_row_ranges.push((new_row, old_row..=old_end_row));
-                                }
-
-                                old_row += line_count;
-                            }
-                            similar::ChangeTag::Insert => {
-                                let new_end_row = new_row + line_count - 1;
-                                let start = new_snapshot.anchor_before(Point::new(new_row, 0));
-                                let end = new_snapshot.anchor_before(Point::new(
-                                    new_end_row,
-                                    new_snapshot.line_len(MultiBufferRow(new_end_row)),
-                                ));
-                                inserted_row_ranges.push(start..=end);
-                                new_row += line_count;
-                            }
-                        }
-                    }
-
-                    (deleted_row_ranges, inserted_row_ranges)
-                })
-                .await;
-
-            codegen
-                .update(&mut cx, |codegen, cx| {
-                    codegen.diff.deleted_row_ranges = deleted_row_ranges;
-                    codegen.diff.inserted_row_ranges = inserted_row_ranges;
-                    cx.notify();
-                })
-                .ok();
-        })
-    }
 }
 
 struct StripInvalidSpans<T> {

crates/assistant/src/model_selector.rs

@@ -1,16 +1,14 @@
 use feature_flags::ZedPro;
-use gpui::Action;
-use gpui::DismissEvent;
-
 use language_model::{LanguageModel, LanguageModelAvailability, LanguageModelRegistry};
 use proto::Plan;
-use workspace::ShowConfiguration;
 
 use std::sync::Arc;
 use ui::ListItemSpacing;
 
 use crate::assistant_settings::AssistantSettings;
+use crate::ShowConfiguration;
 use fs::Fs;
+use gpui::Action;
 use gpui::SharedString;
 use gpui::Task;
 use picker::{Picker, PickerDelegate};
@@ -37,7 +35,7 @@ pub struct ModelPickerDelegate {
 #[derive(Clone)]
 struct ModelInfo {
     model: Arc<dyn LanguageModel>,
-    icon: IconName,
+    provider_icon: IconName,
     availability: LanguageModelAvailability,
     is_selected: bool,
 }
@@ -134,8 +132,6 @@ impl PickerDelegate for ModelPickerDelegate {
                 model.is_selected = model.model.id() == selected_model_id
                     && model.model.provider_id() == selected_provider_id;
             }
-
-            cx.emit(DismissEvent);
         }
     }
 
@@ -150,8 +146,6 @@ impl PickerDelegate for ModelPickerDelegate {
         use feature_flags::FeatureFlagAppExt;
         let model_info = self.filtered_models.get(ix)?;
         let show_badges = cx.has_flag::<ZedPro>();
-        let provider_name: String = model_info.model.provider_name().0.into();
-
         Some(
             ListItem::new(ix)
                 .inset(true)
@@ -159,9 +153,9 @@ impl PickerDelegate for ModelPickerDelegate {
                 .selected(selected)
                 .start_slot(
                     div().pr_1().child(
-                        Icon::new(model_info.icon)
+                        Icon::new(model_info.provider_icon)
                             .color(Color::Muted)
-                            .size(IconSize::Medium),
+                            .size(IconSize::XSmall),
                     ),
                 )
                 .child(
@@ -169,16 +163,11 @@ impl PickerDelegate for ModelPickerDelegate {
                         .w_full()
                         .justify_between()
                         .font_buffer(cx)
-                        .min_w(px(240.))
+                        .min_w(px(200.))
                         .child(
                             h_flex()
                                 .gap_2()
                                 .child(Label::new(model_info.model.name().0.clone()))
-                                .child(
-                                    Label::new(provider_name)
-                                        .size(LabelSize::XSmall)
-                                        .color(Color::Muted),
-                                )
                                 .children(match model_info.availability {
                                     LanguageModelAvailability::Public => None,
                                     LanguageModelAvailability::RequiresPlan(Plan::Free) => None,
@@ -269,17 +258,16 @@ impl<T: PopoverTrigger> RenderOnce for ModelSelector<T> {
             .iter()
             .flat_map(|provider| {
                 let provider_id = provider.id();
-                let icon = provider.icon();
+                let provider_icon = provider.icon();
                 let selected_model = selected_model.clone();
                 let selected_provider = selected_provider.clone();
 
                 provider.provided_models(cx).into_iter().map(move |model| {
                     let model = model.clone();
-                    let icon = model.icon().unwrap_or(icon);
 
                     ModelInfo {
                         model: model.clone(),
-                        icon,
+                        provider_icon,
                         availability: model.availability(),
                         is_selected: selected_model.as_ref() == Some(&model.id())
                             && selected_provider.as_ref() == Some(&provider_id),
@@ -304,6 +292,5 @@ impl<T: PopoverTrigger> RenderOnce for ModelSelector<T> {
             .menu(move |_cx| Some(picker_view.clone()))
             .trigger(self.trigger)
             .attach(gpui::AnchorCorner::BottomLeft)
-            .when_some(self.handle, |menu, handle| menu.with_handle(handle))
     }
 }

crates/assistant/src/prompt_library.rs

@@ -11,8 +11,8 @@ use futures::{
 };
 use fuzzy::StringMatchCandidate;
 use gpui::{
-    actions, point, size, transparent_black, Action, AppContext, BackgroundExecutor, Bounds,
-    EventEmitter, Global, HighlightStyle, PromptLevel, ReadGlobal, Subscription, Task, TextStyle,
+    actions, point, size, transparent_black, AppContext, BackgroundExecutor, Bounds, EventEmitter,
+    Global, HighlightStyle, PromptLevel, ReadGlobal, Subscription, Task, TextStyle,
     TitlebarOptions, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
 };
 use heed::{
@@ -38,7 +38,7 @@ use std::{
 use text::LineEnding;
 use theme::ThemeSettings;
 use ui::{
-    div, prelude::*, IconButtonShape, KeyBinding, ListItem, ListItemSpacing, ParentElement, Render,
+    div, prelude::*, IconButtonShape, ListItem, ListItemSpacing, ParentElement, Render,
     SharedString, Styled, Tooltip, ViewContext, VisualContext,
 };
 use util::{ResultExt, TryFutureExt};
@@ -100,7 +100,7 @@ pub fn open_prompt_library(
                     WindowOptions {
                         titlebar: Some(TitlebarOptions {
                             title: Some("Prompt Library".into()),
-                            appears_transparent: !cfg!(windows),
+                            appears_transparent: true,
                             traffic_light_position: Some(point(px(9.0), px(9.0))),
                         }),
                         window_bounds: Some(WindowBounds::Windowed(bounds)),
@@ -155,14 +155,6 @@ impl PickerDelegate for PromptPickerDelegate {
         self.matches.len()
     }
 
-    fn no_matches_text(&self, _cx: &mut WindowContext) -> SharedString {
-        if self.store.prompt_count() == 0 {
-            "No prompts.".into()
-        } else {
-            "No prompts found matching your search.".into()
-        }
-    }
-
     fn selected_index(&self) -> usize {
         self.selected_index
     }
@@ -494,10 +486,7 @@ impl PromptLibrary {
                             let mut editor = Editor::auto_width(cx);
                             editor.set_placeholder_text("Untitled", cx);
                             editor.set_text(prompt_metadata.title.unwrap_or_default(), cx);
-                            if prompt_id.is_built_in() {
-                                editor.set_read_only(true);
-                                editor.set_show_inline_completions(false);
-                            }
+                            editor.set_read_only(prompt_id.is_built_in());
                             editor
                         });
                         let body_editor = cx.new_view(|cx| {
@@ -509,10 +498,7 @@ impl PromptLibrary {
                             });
 
                             let mut editor = Editor::for_buffer(buffer, None, cx);
-                            if prompt_id.is_built_in() {
-                                editor.set_read_only(true);
-                                editor.set_show_inline_completions(false);
-                            }
+                            editor.set_read_only(prompt_id.is_built_in());
                             editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
                             editor.set_show_gutter(false, cx);
                             editor.set_show_wrap_guides(false, cx);
@@ -789,8 +775,7 @@ impl PromptLibrary {
                                 LanguageModelRequest {
                                     messages: vec![LanguageModelRequestMessage {
                                         role: Role::System,
-                                        content: vec![body.to_string().into()],
-                                        cache: false,
+                                        content: body.to_string(),
                                     }],
                                     stop: Vec::new(),
                                     temperature: 1.,
@@ -1109,55 +1094,7 @@ impl Render for PromptLibrary {
             .font(ui_font)
             .text_color(theme.colors().text)
             .child(self.render_prompt_list(cx))
-            .map(|el| {
-                if self.store.prompt_count() == 0 {
-                    el.child(
-                        v_flex()
-                            .w_2_3()
-                            .h_full()
-                            .items_center()
-                            .justify_center()
-                            .gap_4()
-                            .bg(cx.theme().colors().editor_background)
-                            .child(
-                                h_flex()
-                                    .gap_2()
-                                    .child(
-                                        Icon::new(IconName::Book)
-                                            .size(IconSize::Medium)
-                                            .color(Color::Muted),
-                                    )
-                                    .child(
-                                        Label::new("No prompts yet")
-                                            .size(LabelSize::Large)
-                                            .color(Color::Muted),
-                                    ),
-                            )
-                            .child(
-                                h_flex()
-                                    .child(h_flex())
-                                    .child(
-                                        v_flex()
-                                            .gap_1()
-                                            .child(Label::new("Create your first prompt:"))
-                                            .child(
-                                                Button::new("create-prompt", "New Prompt")
-                                                    .full_width()
-                                                    .key_binding(KeyBinding::for_action(
-                                                        &NewPrompt, cx,
-                                                    ))
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(NewPrompt.boxed_clone())
-                                                    }),
-                                            ),
-                                    )
-                                    .child(h_flex()),
-                            ),
-                    )
-                } else {
-                    el.child(self.render_active_prompt(cx))
-                }
-            })
+            .child(self.render_active_prompt(cx))
     }
 }
 
@@ -1405,11 +1342,6 @@ impl PromptStore {
         })
     }
 
-    /// Returns the number of prompts in the store.
-    fn prompt_count(&self) -> usize {
-        self.metadata_cache.read().metadata.len()
-    }
-
     fn metadata(&self, id: PromptId) -> Option<PromptMetadata> {
         self.metadata_cache.read().metadata_by_id.get(&id).cloned()
     }

crates/assistant/src/prompts.rs

@@ -1,13 +1,11 @@
-use anyhow::Result;
 use assets::Assets;
 use fs::Fs;
 use futures::StreamExt;
-use gpui::AssetSource;
-use handlebars::{Handlebars, RenderError};
+use handlebars::{Handlebars, RenderError, TemplateError};
 use language::BufferSnapshot;
 use parking_lot::Mutex;
 use serde::Serialize;
-use std::{ops::Range, path::PathBuf, sync::Arc, time::Duration};
+use std::{ops::Range, sync::Arc, time::Duration};
 use util::ResultExt;
 
 #[derive(Serialize)]
@@ -31,171 +29,115 @@ pub struct TerminalAssistantPromptContext {
     pub user_prompt: 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>,
-    pub cx: &'a gpui::AppContext,
-}
-
 pub struct PromptBuilder {
     handlebars: Arc<Mutex<Handlebars<'static>>>,
 }
 
 impl PromptBuilder {
-    pub fn new(loading_params: Option<PromptLoadingParams>) -> Result<Self> {
+    pub fn new(
+        fs_and_cx: Option<(Arc<dyn Fs>, &gpui::AppContext)>,
+    ) -> Result<Self, Box<TemplateError>> {
         let mut handlebars = Handlebars::new();
-        Self::register_built_in_templates(&mut handlebars)?;
+        Self::register_templates(&mut handlebars)?;
 
         let handlebars = Arc::new(Mutex::new(handlebars));
 
-        if let Some(params) = loading_params {
-            Self::watch_fs_for_template_overrides(params, handlebars.clone());
+        if let Some((fs, cx)) = fs_and_cx {
+            Self::watch_fs_for_template_overrides(fs, cx, handlebars.clone());
         }
 
         Ok(Self { handlebars })
     }
 
-    /// Watches the filesystem for changes to prompt template overrides.
-    ///
-    /// This function sets up a file watcher on the prompt templates directory. It performs
-    /// an initial scan of the directory and registers any existing template overrides.
-    /// Then it continuously monitors for changes, reloading templates as they are
-    /// modified or added.
-    ///
-    /// If the templates directory doesn't exist initially, it waits for it to be created.
-    /// If the directory is removed, it restores the built-in templates and waits for the
-    /// directory to be recreated.
-    ///
-    /// # Arguments
-    ///
-    /// * `params` - A `PromptLoadingParams` struct containing the filesystem, repository path,
-    ///   and application context.
-    /// * `handlebars` - An `Arc<Mutex<Handlebars>>` for registering and updating templates.
     fn watch_fs_for_template_overrides(
-        mut params: PromptLoadingParams,
+        fs: Arc<dyn Fs>,
+        cx: &gpui::AppContext,
         handlebars: Arc<Mutex<Handlebars<'static>>>,
     ) {
-        params.repo_path = None;
-        let templates_dir = paths::prompt_overrides_dir(params.repo_path.as_deref());
-        params.cx.background_executor()
+        let templates_dir = paths::prompt_templates_dir();
+
+        cx.background_executor()
             .spawn(async move {
-                let Some(parent_dir) = templates_dir.parent() else {
-                    return;
-                };
-
-                let mut found_dir_once = false;
-                loop {
-                    // Check if the templates directory exists and handle its status
-                    // If it exists, log its presence and check if it's a symlink
-                    // If it doesn't exist:
-                    //   - Log that we're using built-in prompts
-                    //   - Check if it's a broken symlink and log if so
-                    //   - Set up a watcher to detect when it's created
-                    // After the first check, set the `found_dir_once` flag
-                    // This allows us to avoid logging when looping back around after deleting the prompt overrides directory.
-                    let dir_status = params.fs.is_dir(&templates_dir).await;
-                    let symlink_status = params.fs.read_link(&templates_dir).await.ok();
-                    if dir_status {
-                        let mut log_message = format!("Prompt template overrides directory found at {}", templates_dir.display());
-                        if let Some(target) = symlink_status {
-                            log_message.push_str(" -> ");
-                            log_message.push_str(&target.display().to_string());
-                        }
-                        log::info!("{}.", log_message);
-                    } else {
-                        if !found_dir_once {
-                            log::info!("No prompt template overrides directory found at {}. Using built-in prompts.", templates_dir.display());
-                            if let Some(target) = symlink_status {
-                                log::info!("Symlink found pointing to {}, but target is invalid.", target.display());
-                            }
-                        }
-
-                        if params.fs.is_dir(parent_dir).await {
-                            let (mut changes, _watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;
-                            while let Some(changed_paths) = changes.next().await {
-                                if changed_paths.iter().any(|p| p == &templates_dir) {
-                                    let mut log_message = format!("Prompt template overrides directory detected at {}", templates_dir.display());
-                                    if let Ok(target) = params.fs.read_link(&templates_dir).await {
-                                        log_message.push_str(" -> ");
-                                        log_message.push_str(&target.display().to_string());
-                                    }
-                                    log::info!("{}.", log_message);
-                                    break;
-                                }
-                            }
-                        } else {
-                            return;
-                        }
+                // Create the prompt templates directory if it doesn't exist
+                if !fs.is_dir(templates_dir).await {
+                    if let Err(e) = fs.create_dir(templates_dir).await {
+                        log::error!("Failed to create prompt templates directory: {}", e);
+                        return;
                     }
-
-                    found_dir_once = true;
-
-                    // Initial scan of the prompt overrides directory
-                    if let Ok(mut entries) = params.fs.read_dir(&templates_dir).await {
-                        while let Some(Ok(file_path)) = entries.next().await {
-                            if file_path.to_string_lossy().ends_with(".hbs") {
-                                if let Ok(content) = params.fs.load(&file_path).await {
-                                    let file_name = file_path.file_stem().unwrap().to_string_lossy();
-                                    log::info!("Registering prompt template override: {}", file_name);
-                                    handlebars.lock().register_template_string(&file_name, content).log_err();
-                                }
-                            }
-                        }
-                    }
-
-                    // Watch both the parent directory and the template overrides directory:
-                    // - Monitor the parent directory to detect if the template overrides directory is deleted.
-                    // - Monitor the template overrides directory to re-register templates when they change.
-                    // Combine both watch streams into a single stream.
-                    let (parent_changes, parent_watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;
-                    let (changes, watcher) = params.fs.watch(&templates_dir, Duration::from_secs(1)).await;
-                    let mut combined_changes = futures::stream::select(changes, parent_changes);
-
-                    while let Some(changed_paths) = combined_changes.next().await {
-                        if changed_paths.iter().any(|p| p == &templates_dir) {
-                            if !params.fs.is_dir(&templates_dir).await {
-                                log::info!("Prompt template overrides directory removed. Restoring built-in prompt templates.");
-                                Self::register_built_in_templates(&mut handlebars.lock()).log_err();
-                                break;
-                            }
-                        }
-                        for changed_path in changed_paths {
-                            if changed_path.starts_with(&templates_dir) && changed_path.extension().map_or(false, |ext| ext == "hbs") {
-                                log::info!("Reloading prompt template override: {}", changed_path.display());
-                                if let Some(content) = params.fs.load(&changed_path).await.log_err() {
-                                    let file_name = changed_path.file_stem().unwrap().to_string_lossy();
-                                    handlebars.lock().register_template_string(&file_name, content).log_err();
-                                }
-                            }
-                        }
-                    }
-
-                    drop(watcher);
-                    drop(parent_watcher);
                 }
+
+                // Initial scan of the prompts directory
+                if let Ok(mut entries) = fs.read_dir(templates_dir).await {
+                    while let Some(Ok(file_path)) = entries.next().await {
+                        if file_path.to_string_lossy().ends_with(".hbs") {
+                            if let Ok(content) = fs.load(&file_path).await {
+                                let file_name = file_path.file_stem().unwrap().to_string_lossy();
+
+                                match handlebars.lock().register_template_string(&file_name, content) {
+                                    Ok(_) => {
+                                        log::info!(
+                                            "Successfully registered template override: {} ({})",
+                                            file_name,
+                                            file_path.display()
+                                        );
+                                    },
+                                    Err(e) => {
+                                        log::error!(
+                                            "Failed to register template during initial scan: {} ({})",
+                                            e,
+                                            file_path.display()
+                                        );
+                                    },
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Watch for changes
+                let (mut changes, watcher) = fs.watch(templates_dir, Duration::from_secs(1)).await;
+                while let Some(changed_paths) = changes.next().await {
+                    for changed_path in changed_paths {
+                        if changed_path.extension().map_or(false, |ext| ext == "hbs") {
+                            log::info!("Reloading template: {}", changed_path.display());
+                            if let Some(content) = fs.load(&changed_path).await.log_err() {
+                                let file_name = changed_path.file_stem().unwrap().to_string_lossy();
+                                let file_path = changed_path.to_string_lossy();
+                                match handlebars.lock().register_template_string(&file_name, content) {
+                                    Ok(_) => log::info!(
+                                        "Successfully reloaded template: {} ({})",
+                                        file_name,
+                                        file_path
+                                    ),
+                                    Err(e) => log::error!(
+                                        "Failed to register template: {} ({})",
+                                        e,
+                                        file_path
+                                    ),
+                                }
+                            }
+                        }
+                    }
+                }
+                drop(watcher);
             })
             .detach();
     }
 
-    fn register_built_in_templates(handlebars: &mut Handlebars) -> Result<()> {
-        for path in Assets.list("prompts")? {
-            if let Some(id) = path.split('/').last().and_then(|s| s.strip_suffix(".hbs")) {
-                if let Some(prompt) = Assets.load(path.as_ref()).log_err().flatten() {
-                    log::info!("Registering built-in prompt template: {}", id);
-                    handlebars
-                        .register_template_string(id, String::from_utf8_lossy(prompt.as_ref()))?
-                }
-            }
-        }
+    fn register_templates(handlebars: &mut Handlebars) -> Result<(), Box<TemplateError>> {
+        let mut register_template = |id: &str| {
+            let prompt = Assets::get(&format!("prompts/{}.hbs", id))
+                .unwrap_or_else(|| panic!("{} prompt template not found", id))
+                .data;
+            handlebars
+                .register_template_string(id, String::from_utf8_lossy(&prompt))
+                .map_err(Box::new)
+        };
+
+        register_template("content_prompt")?;
+        register_template("terminal_assistant_prompt")?;
+        register_template("edit_workflow")?;
+        register_template("step_resolution")?;
 
         Ok(())
     }
@@ -297,10 +239,7 @@ impl PromptBuilder {
         self.handlebars.lock().render("edit_workflow", &())
     }
 
-    pub fn generate_step_resolution_prompt(
-        &self,
-        context: &StepResolutionContext,
-    ) -> Result<String, RenderError> {
-        self.handlebars.lock().render("step_resolution", context)
+    pub fn generate_step_resolution_prompt(&self) -> Result<String, RenderError> {
+        self.handlebars.lock().render("step_resolution", &())
     }
 }

crates/assistant/src/slash_command.rs

@@ -1,13 +1,11 @@
 use crate::assistant_panel::ContextEditor;
 use anyhow::Result;
-use assistant_slash_command::AfterCompletion;
 pub use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandRegistry};
 use editor::{CompletionProvider, Editor};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{AppContext, Model, Task, ViewContext, WeakView, WindowContext};
 use language::{Anchor, Buffer, CodeLabel, Documentation, HighlightId, LanguageServerId, ToPoint};
 use parking_lot::{Mutex, RwLock};
-use project::CompletionIntent;
 use rope::Point;
 use std::{
     ops::Range,
@@ -19,7 +17,7 @@ use std::{
 use ui::ActiveTheme;
 use workspace::Workspace;
 
-pub mod context_server_command;
+pub mod active_command;
 pub mod default_command;
 pub mod diagnostics_command;
 pub mod docs_command;
@@ -30,8 +28,8 @@ pub mod project_command;
 pub mod prompt_command;
 pub mod search_command;
 pub mod symbols_command;
-pub mod tab_command;
-pub mod terminal_command;
+pub mod tabs_command;
+pub mod term_command;
 pub mod workflow_command;
 
 pub(crate) struct SlashCommandCompletionProvider {
@@ -43,8 +41,8 @@ pub(crate) struct SlashCommandCompletionProvider {
 pub(crate) struct SlashCommandLine {
     /// The range within the line containing the command name.
     pub name: Range<usize>,
-    /// Ranges within the line containing the command arguments.
-    pub arguments: Vec<Range<usize>>,
+    /// The range within the line containing the command argument.
+    pub argument: Option<Range<usize>>,
 }
 
 impl SlashCommandCompletionProvider {
@@ -98,45 +96,34 @@ impl SlashCommandCompletionProvider {
                         let command = commands.command(&mat.string)?;
                         let mut new_text = mat.string.clone();
                         let requires_argument = command.requires_argument();
-                        let accepts_arguments = command.accepts_arguments();
-                        if requires_argument || accepts_arguments {
+                        if requires_argument {
                             new_text.push(' ');
                         }
 
-                        let confirm =
-                            editor
-                                .clone()
-                                .zip(workspace.clone())
-                                .map(|(editor, workspace)| {
+                        let confirm = editor.clone().zip(workspace.clone()).and_then(
+                            |(editor, workspace)| {
+                                (!requires_argument).then(|| {
                                     let command_name = mat.string.clone();
                                     let command_range = command_range.clone();
                                     let editor = editor.clone();
                                     let workspace = workspace.clone();
-                                    Arc::new(
-                                        move |intent: CompletionIntent, cx: &mut WindowContext| {
-                                            if !requires_argument
-                                                && (!accepts_arguments || intent.is_complete())
-                                            {
-                                                editor
-                                                    .update(cx, |editor, cx| {
-                                                        editor.run_command(
-                                                            command_range.clone(),
-                                                            &command_name,
-                                                            &[],
-                                                            true,
-                                                            false,
-                                                            workspace.clone(),
-                                                            cx,
-                                                        );
-                                                    })
-                                                    .ok();
-                                                false
-                                            } else {
-                                                requires_argument || accepts_arguments
-                                            }
-                                        },
-                                    ) as Arc<_>
-                                });
+                                    Arc::new(move |cx: &mut WindowContext| {
+                                        editor
+                                            .update(cx, |editor, cx| {
+                                                editor.run_command(
+                                                    command_range.clone(),
+                                                    &command_name,
+                                                    None,
+                                                    true,
+                                                    workspace.clone(),
+                                                    cx,
+                                                );
+                                            })
+                                            .ok();
+                                    }) as Arc<_>
+                                })
+                            },
+                        );
                         Some(project::Completion {
                             old_range: name_range.clone(),
                             documentation: Some(Documentation::SingleLine(command.description())),
@@ -144,6 +131,7 @@ impl SlashCommandCompletionProvider {
                             label: command.label(cx),
                             server_id: LanguageServerId(0),
                             lsp_completion: Default::default(),
+                            show_new_completions_on_confirm: requires_argument,
                             confirm,
                         })
                     })
@@ -155,20 +143,20 @@ impl SlashCommandCompletionProvider {
     fn complete_command_argument(
         &self,
         command_name: &str,
-        arguments: &[String],
+        argument: String,
         command_range: Range<Anchor>,
         argument_range: Range<Anchor>,
-        last_argument_range: Range<Anchor>,
         cx: &mut WindowContext,
     ) -> Task<Result<Vec<project::Completion>>> {
         let new_cancel_flag = Arc::new(AtomicBool::new(false));
         let mut flag = self.cancel_flag.lock();
         flag.store(true, SeqCst);
         *flag = new_cancel_flag.clone();
+
         let commands = SlashCommandRegistry::global(cx);
         if let Some(command) = commands.command(command_name) {
             let completions = command.complete_argument(
-                arguments,
+                argument,
                 new_cancel_flag.clone(),
                 self.workspace.clone(),
                 cx,
@@ -176,76 +164,61 @@ impl SlashCommandCompletionProvider {
             let command_name: Arc<str> = command_name.into();
             let editor = self.editor.clone();
             let workspace = self.workspace.clone();
-            let arguments = arguments.to_vec();
             cx.background_executor().spawn(async move {
                 Ok(completions
                     .await?
                     .into_iter()
-                    .map(|new_argument| {
-                        let confirm =
+                    .map(|command_argument| {
+                        let confirm = if command_argument.run_command {
                             editor
                                 .clone()
                                 .zip(workspace.clone())
                                 .map(|(editor, workspace)| {
                                     Arc::new({
-                                        let mut completed_arguments = arguments.clone();
-                                        if new_argument.replace_previous_arguments {
-                                            completed_arguments.clear();
-                                        } else {
-                                            completed_arguments.pop();
-                                        }
-                                        completed_arguments.push(new_argument.new_text.clone());
-
                                         let command_range = command_range.clone();
                                         let command_name = command_name.clone();
-                                        move |intent: CompletionIntent, cx: &mut WindowContext| {
-                                            if new_argument.after_completion.run()
-                                                || intent.is_complete()
-                                            {
-                                                editor
-                                                    .update(cx, |editor, cx| {
-                                                        editor.run_command(
-                                                            command_range.clone(),
-                                                            &command_name,
-                                                            &completed_arguments,
-                                                            true,
-                                                            false,
-                                                            workspace.clone(),
-                                                            cx,
-                                                        );
-                                                    })
-                                                    .ok();
-                                                false
-                                            } else {
-                                                !new_argument.after_completion.run()
-                                            }
+                                        let command_argument = command_argument.new_text.clone();
+                                        move |cx: &mut WindowContext| {
+                                            editor
+                                                .update(cx, |editor, cx| {
+                                                    editor.run_command(
+                                                        command_range.clone(),
+                                                        &command_name,
+                                                        Some(&command_argument),
+                                                        true,
+                                                        workspace.clone(),
+                                                        cx,
+                                                    );
+                                                })
+                                                .ok();
                                         }
                                     }) as Arc<_>
-                                });
+                                })
+                        } else {
+                            None
+                        };
 
-                        let mut new_text = new_argument.new_text.clone();
-                        if new_argument.after_completion == AfterCompletion::Continue {
+                        let mut new_text = command_argument.new_text.clone();
+                        if !command_argument.run_command {
                             new_text.push(' ');
                         }
 
                         project::Completion {
-                            old_range: if new_argument.replace_previous_arguments {
-                                argument_range.clone()
-                            } else {
-                                last_argument_range.clone()
-                            },
-                            label: new_argument.label,
+                            old_range: argument_range.clone(),
+                            label: CodeLabel::plain(command_argument.label, None),
                             new_text,
                             documentation: None,
                             server_id: LanguageServerId(0),
                             lsp_completion: Default::default(),
+                            show_new_completions_on_confirm: !command_argument.run_command,
                             confirm,
                         }
                     })
                     .collect())
             })
         } else {
-            Task::ready(Ok(Vec::new()))
+            cx.background_executor()
+                .spawn(async move { Ok(Vec::new()) })
         }
     }
 }
@@ -258,7 +231,7 @@ impl CompletionProvider for SlashCommandCompletionProvider {
         _: editor::CompletionContext,
         cx: &mut ViewContext<Editor>,
     ) -> Task<Result<Vec<project::Completion>>> {
-        let Some((name, arguments, command_range, last_argument_range)) =
+        let Some((name, argument, command_range, argument_range)) =
             buffer.update(cx, |buffer, _cx| {
                 let position = buffer_position.to_point(buffer);
                 let line_start = Point::new(position.row, 0);
@@ -269,52 +242,32 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                 let command_range_start = Point::new(position.row, call.name.start as u32 - 1);
                 let command_range_end = Point::new(
                     position.row,
-                    call.arguments.last().map_or(call.name.end, |arg| arg.end) as u32,
+                    call.argument.as_ref().map_or(call.name.end, |arg| arg.end) as u32,
                 );
                 let command_range = buffer.anchor_after(command_range_start)
                     ..buffer.anchor_after(command_range_end);
 
                 let name = line[call.name.clone()].to_string();
-                let (arguments, last_argument_range) = if let Some(argument) = call.arguments.last()
-                {
-                    let last_arg_start =
+
+                Some(if let Some(argument) = call.argument {
+                    let start =
                         buffer.anchor_after(Point::new(position.row, argument.start as u32));
-                    let first_arg_start = call.arguments.first().expect("we have the last element");
-                    let first_arg_start =
-                        buffer.anchor_after(Point::new(position.row, first_arg_start.start as u32));
-                    let arguments = call
-                        .arguments
-                        .iter()
-                        .filter_map(|argument| Some(line.get(argument.clone())?.to_string()))
-                        .collect::<Vec<_>>();
-                    let argument_range = first_arg_start..buffer_position;
-                    (
-                        Some((arguments, argument_range)),
-                        last_arg_start..buffer_position,
-                    )
+                    let argument = line[argument.clone()].to_string();
+                    (name, Some(argument), command_range, start..buffer_position)
                 } else {
                     let start =
                         buffer.anchor_after(Point::new(position.row, call.name.start as u32));
-                    (None, start..buffer_position)
-                };
-
-                Some((name, arguments, command_range, last_argument_range))
+                    (name, None, command_range, start..buffer_position)
+                })
             })
         else {
             return Task::ready(Ok(Vec::new()));
         };
 
-        if let Some((arguments, argument_range)) = arguments {
-            self.complete_command_argument(
-                &name,
-                &arguments,
-                command_range,
-                argument_range,
-                last_argument_range,
-                cx,
-            )
+        if let Some(argument) = argument {
+            self.complete_command_argument(&name, argument, command_range, argument_range, cx)
         } else {
-            self.complete_command_name(&name, command_range, last_argument_range, cx)
+            self.complete_command_name(&name, command_range, argument_range, cx)
         }
     }
 
@@ -356,10 +309,6 @@ impl CompletionProvider for SlashCommandCompletionProvider {
             false
         }
     }
-
-    fn sort_completions(&self) -> bool {
-        false
-    }
 }
 
 impl SlashCommandLine {
@@ -371,23 +320,16 @@ impl SlashCommandLine {
             if let Some(call) = &mut call {
                 // The command arguments start at the first non-whitespace character
                 // after the command name, and continue until the end of the line.
-                if let Some(argument) = call.arguments.last_mut() {
-                    if c.is_whitespace() {
-                        if (*argument).is_empty() {
-                            argument.start = next_ix;
-                            argument.end = next_ix;
-                        } else {
-                            argument.end = ix;
-                            call.arguments.push(next_ix..next_ix);
-                        }
-                    } else {
-                        argument.end = next_ix;
+                if let Some(argument) = &mut call.argument {
+                    if (*argument).is_empty() && c.is_whitespace() {
+                        argument.start = next_ix;
                     }
+                    argument.end = next_ix;
                 }
                 // The command name ends at the first whitespace character.
                 else if !call.name.is_empty() {
                     if c.is_whitespace() {
-                        call.arguments = vec![next_ix..next_ix];
+                        call.argument = Some(next_ix..next_ix);
                     } else {
                         call.name.end = next_ix;
                     }
@@ -403,7 +345,7 @@ impl SlashCommandLine {
             else if c == '/' {
                 call = Some(SlashCommandLine {
                     name: next_ix..next_ix,
-                    arguments: Vec::new(),
+                    argument: None,
                 });
             }
             // The line can't contain anything before the slash except for whitespace.

crates/assistant/src/slash_command/active_command.rs

@@ -0,0 +1,102 @@
+use super::{
+    diagnostics_command::write_single_file_diagnostics,
+    file_command::{build_entry_output_section, codeblock_fence_for_path},
+    SlashCommand, SlashCommandOutput,
+};
+use anyhow::{anyhow, Result};
+use assistant_slash_command::ArgumentCompletion;
+use editor::Editor;
+use gpui::{AppContext, Task, WeakView};
+use language::LspAdapterDelegate;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+use ui::WindowContext;
+use workspace::Workspace;
+
+pub(crate) struct ActiveSlashCommand;
+
+impl SlashCommand for ActiveSlashCommand {
+    fn name(&self) -> String {
+        "active".into()
+    }
+
+    fn description(&self) -> String {
+        "insert active tab".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Active Tab".into()
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _query: String,
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut AppContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Err(anyhow!("this command does not require argument")))
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _argument: Option<&str>,
+        workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let output = workspace.update(cx, |workspace, cx| {
+            let Some(active_item) = workspace.active_item(cx) else {
+                return Task::ready(Err(anyhow!("no active tab")));
+            };
+            let Some(buffer) = active_item
+                .downcast::<Editor>()
+                .and_then(|editor| editor.read(cx).buffer().read(cx).as_singleton())
+            else {
+                return Task::ready(Err(anyhow!("active tab is not an editor")));
+            };
+
+            let snapshot = buffer.read(cx).snapshot();
+            let path = snapshot.resolve_file_path(cx, true);
+            let task = cx.background_executor().spawn({
+                let path = path.clone();
+                async move {
+                    let mut output = String::new();
+                    output.push_str(&codeblock_fence_for_path(path.as_deref(), None));
+                    for chunk in snapshot.as_rope().chunks() {
+                        output.push_str(chunk);
+                    }
+                    if !output.ends_with('\n') {
+                        output.push('\n');
+                    }
+                    output.push_str("```\n");
+                    let has_diagnostics =
+                        write_single_file_diagnostics(&mut output, path.as_deref(), &snapshot);
+                    if output.ends_with('\n') {
+                        output.pop();
+                    }
+                    (output, has_diagnostics)
+                }
+            });
+            cx.foreground_executor().spawn(async move {
+                let (text, has_diagnostics) = task.await;
+                let range = 0..text.len();
+                Ok(SlashCommandOutput {
+                    text,
+                    sections: vec![build_entry_output_section(
+                        range,
+                        path.as_deref(),
+                        false,
+                        None,
+                    )],
+                    run_commands_in_text: has_diagnostics,
+                })
+            })
+        });
+        output.unwrap_or_else(|error| Task::ready(Err(error)))
+    }
+}

crates/assistant/src/slash_command/context_server_command.rs

@@ -1,134 +0,0 @@
-use anyhow::{anyhow, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-};
-use collections::HashMap;
-use context_servers::{
-    manager::{ContextServer, ContextServerManager},
-    protocol::PromptInfo,
-};
-use gpui::{Task, WeakView, WindowContext};
-use language::LspAdapterDelegate;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-use ui::{IconName, SharedString};
-use workspace::Workspace;
-
-pub struct ContextServerSlashCommand {
-    server_id: String,
-    prompt: PromptInfo,
-}
-
-impl ContextServerSlashCommand {
-    pub fn new(server: &Arc<ContextServer>, prompt: PromptInfo) -> Self {
-        Self {
-            server_id: server.id.clone(),
-            prompt,
-        }
-    }
-}
-
-impl SlashCommand for ContextServerSlashCommand {
-    fn name(&self) -> String {
-        self.prompt.name.clone()
-    }
-
-    fn description(&self) -> String {
-        format!("Run context server command: {}", self.prompt.name)
-    }
-
-    fn menu_text(&self) -> String {
-        format!("Run '{}' from {}", self.prompt.name, self.server_id)
-    }
-
-    fn requires_argument(&self) -> bool {
-        self.prompt
-            .arguments
-            .as_ref()
-            .map_or(false, |args| !args.is_empty())
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Ok(Vec::new()))
-    }
-
-    fn run(
-        self: Arc<Self>,
-        arguments: &[String],
-        _workspace: WeakView<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<SlashCommandOutput>> {
-        let server_id = self.server_id.clone();
-        let prompt_name = self.prompt.name.clone();
-
-        let prompt_args = match prompt_arguments(&self.prompt, arguments) {
-            Ok(args) => args,
-            Err(e) => return Task::ready(Err(e)),
-        };
-
-        let manager = ContextServerManager::global(cx);
-        let manager = manager.read(cx);
-        if let Some(server) = manager.get_server(&server_id) {
-            cx.foreground_executor().spawn(async move {
-                let Some(protocol) = server.client.read().clone() else {
-                    return Err(anyhow!("Context server not initialized"));
-                };
-                let result = protocol.run_prompt(&prompt_name, prompt_args).await?;
-
-                Ok(SlashCommandOutput {
-                    sections: vec![SlashCommandOutputSection {
-                        range: 0..result.len(),
-                        icon: IconName::ZedAssistant,
-                        label: SharedString::from(format!("Result from {}", prompt_name)),
-                    }],
-                    text: result,
-                    run_commands_in_text: false,
-                })
-            })
-        } else {
-            Task::ready(Err(anyhow!("Context server not found")))
-        }
-    }
-}
-
-fn prompt_arguments(prompt: &PromptInfo, arguments: &[String]) -> Result<HashMap<String, String>> {
-    match &prompt.arguments {
-        Some(args) if args.len() > 1 => Err(anyhow!(
-            "Prompt has more than one argument, which is not supported"
-        )),
-        Some(args) if args.len() == 1 => {
-            if !arguments.is_empty() {
-                let mut map = HashMap::default();
-                map.insert(args[0].name.clone(), arguments.join(" "));
-                Ok(map)
-            } else {
-                Err(anyhow!("Prompt expects argument but none given"))
-            }
-        }
-        Some(_) | None => {
-            if arguments.is_empty() {
-                Ok(HashMap::default())
-            } else {
-                Err(anyhow!("Prompt expects no arguments but some were given"))
-            }
-        }
-    }
-}
-
-/// MCP servers can return prompts with multiple arguments. Since we only
-/// support one argument, we ignore all others. This is the necessary predicate
-/// for this.
-pub fn acceptable_prompt(prompt: &PromptInfo) -> bool {
-    match &prompt.arguments {
-        None => true,
-        Some(args) if args.len() == 1 => true,
-        _ => false,
-    }
-}

crates/assistant/src/slash_command/default_command.rs

@@ -2,7 +2,7 @@ use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
-use gpui::{Task, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::{
     fmt::Write,
@@ -32,17 +32,17 @@ impl SlashCommand for DefaultSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancellation_flag: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Err(anyhow!("this command does not require argument")))
     }
 
     fn run(
         self: Arc<Self>,
-        _arguments: &[String],
+        _argument: Option<&str>,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,

crates/assistant/src/slash_command/diagnostics_command.rs

@@ -43,7 +43,6 @@ impl DiagnosticsSlashCommand {
                         worktree_id: entry.worktree_id.to_usize(),
                         path: entry.path.clone(),
                         path_prefix: path_prefix.clone(),
-                        is_dir: false, // Diagnostics can't be produced for directories
                         distance_to_relative_ancestor: 0,
                     })
                     .collect(),
@@ -103,21 +102,17 @@ impl SlashCommand for DiagnosticsSlashCommand {
         false
     }
 
-    fn accepts_arguments(&self) -> bool {
-        true
-    }
-
     fn complete_argument(
         self: Arc<Self>,
-        arguments: &[String],
+        query: String,
         cancellation_flag: Arc<AtomicBool>,
         workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
+        cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         let Some(workspace) = workspace.and_then(|workspace| workspace.upgrade()) else {
             return Task::ready(Err(anyhow!("workspace was dropped")));
         };
-        let query = arguments.last().cloned().unwrap_or_default();
+        let query = query.split_whitespace().last().unwrap_or("").to_string();
 
         let paths = self.search_paths(query.clone(), cancellation_flag.clone(), &workspace, cx);
         let executor = cx.background_executor().clone();
@@ -151,10 +146,9 @@ impl SlashCommand for DiagnosticsSlashCommand {
             Ok(matches
                 .into_iter()
                 .map(|completion| ArgumentCompletion {
-                    label: completion.clone().into(),
+                    label: completion.clone(),
                     new_text: completion,
-                    after_completion: assistant_slash_command::AfterCompletion::Run,
-                    replace_previous_arguments: false,
+                    run_command: true,
                 })
                 .collect())
         })
@@ -162,7 +156,7 @@ impl SlashCommand for DiagnosticsSlashCommand {
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -171,69 +165,61 @@ impl SlashCommand for DiagnosticsSlashCommand {
             return Task::ready(Err(anyhow!("workspace was dropped")));
         };
 
-        let options = Options::parse(arguments);
+        let options = Options::parse(argument);
 
         let task = collect_diagnostics(workspace.read(cx).project().clone(), options, cx);
-
         cx.spawn(move |_| async move {
             let Some((text, sections)) = task.await? else {
-                return Ok(SlashCommandOutput {
-                    sections: vec![SlashCommandOutputSection {
-                        range: 0..1,
-                        icon: IconName::Library,
-                        label: "No Diagnostics".into(),
-                    }],
-                    text: "\n".to_string(),
-                    run_commands_in_text: true,
-                });
+                return Ok(SlashCommandOutput::default());
             };
 
-            let sections = sections
-                .into_iter()
-                .map(|(range, placeholder_type)| SlashCommandOutputSection {
-                    range,
-                    icon: match placeholder_type {
-                        PlaceholderType::Root(_, _) => IconName::ExclamationTriangle,
-                        PlaceholderType::File(_) => IconName::File,
-                        PlaceholderType::Diagnostic(DiagnosticType::Error, _) => IconName::XCircle,
-                        PlaceholderType::Diagnostic(DiagnosticType::Warning, _) => {
-                            IconName::ExclamationTriangle
-                        }
-                    },
-                    label: match placeholder_type {
-                        PlaceholderType::Root(summary, source) => {
-                            let mut label = String::new();
-                            label.push_str("Diagnostics");
-                            if let Some(source) = source {
-                                write!(label, " ({})", source).unwrap();
-                            }
-
-                            if summary.error_count > 0 || summary.warning_count > 0 {
-                                label.push(':');
-
-                                if summary.error_count > 0 {
-                                    write!(label, " {} errors", summary.error_count).unwrap();
-                                    if summary.warning_count > 0 {
-                                        label.push_str(",");
-                                    }
-                                }
-
-                                if summary.warning_count > 0 {
-                                    write!(label, " {} warnings", summary.warning_count).unwrap();
-                                }
-                            }
-
-                            label.into()
-                        }
-                        PlaceholderType::File(file_path) => file_path.into(),
-                        PlaceholderType::Diagnostic(_, message) => message.into(),
-                    },
-                })
-                .collect();
-
             Ok(SlashCommandOutput {
                 text,
-                sections,
+                sections: sections
+                    .into_iter()
+                    .map(|(range, placeholder_type)| SlashCommandOutputSection {
+                        range,
+                        icon: match placeholder_type {
+                            PlaceholderType::Root(_, _) => IconName::ExclamationTriangle,
+                            PlaceholderType::File(_) => IconName::File,
+                            PlaceholderType::Diagnostic(DiagnosticType::Error, _) => {
+                                IconName::XCircle
+                            }
+                            PlaceholderType::Diagnostic(DiagnosticType::Warning, _) => {
+                                IconName::ExclamationTriangle
+                            }
+                        },
+                        label: match placeholder_type {
+                            PlaceholderType::Root(summary, source) => {
+                                let mut label = String::new();
+                                label.push_str("Diagnostics");
+                                if let Some(source) = source {
+                                    write!(label, " ({})", source).unwrap();
+                                }
+
+                                if summary.error_count > 0 || summary.warning_count > 0 {
+                                    label.push(':');
+
+                                    if summary.error_count > 0 {
+                                        write!(label, " {} errors", summary.error_count).unwrap();
+                                        if summary.warning_count > 0 {
+                                            label.push_str(",");
+                                        }
+                                    }
+
+                                    if summary.warning_count > 0 {
+                                        write!(label, " {} warnings", summary.warning_count)
+                                            .unwrap();
+                                    }
+                                }
+
+                                label.into()
+                            }
+                            PlaceholderType::File(file_path) => file_path.into(),
+                            PlaceholderType::Diagnostic(_, message) => message.into(),
+                        },
+                    })
+                    .collect(),
                 run_commands_in_text: false,
             })
         })
@@ -249,20 +235,25 @@ struct Options {
 const INCLUDE_WARNINGS_ARGUMENT: &str = "--include-warnings";
 
 impl Options {
-    fn parse(arguments: &[String]) -> Self {
-        let mut include_warnings = false;
-        let mut path_matcher = None;
-        for arg in arguments {
-            if arg == INCLUDE_WARNINGS_ARGUMENT {
-                include_warnings = true;
-            } else {
-                path_matcher = PathMatcher::new(&[arg.to_owned()]).log_err();
-            }
-        }
-        Self {
-            include_warnings,
-            path_matcher,
-        }
+    fn parse(arguments_line: Option<&str>) -> Self {
+        arguments_line
+            .map(|arguments_line| {
+                let args = arguments_line.split_whitespace().collect::<Vec<_>>();
+                let mut include_warnings = false;
+                let mut path_matcher = None;
+                for arg in args {
+                    if arg == INCLUDE_WARNINGS_ARGUMENT {
+                        include_warnings = true;
+                    } else {
+                        path_matcher = PathMatcher::new(&[arg.to_owned()]).log_err();
+                    }
+                }
+                Self {
+                    include_warnings,
+                    path_matcher,
+                }
+            })
+            .unwrap_or_default()
     }
 
     fn match_candidates_for_args() -> [StringMatchCandidate; 1] {

crates/assistant/src/slash_command/docs_command.rs

@@ -161,28 +161,30 @@ impl SlashCommand for DocsSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        arguments: &[String],
+        query: String,
         _cancel: Arc<AtomicBool>,
         workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
+        cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         self.ensure_rust_doc_providers_are_registered(workspace, cx);
 
         let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        let args = DocsSlashCommandArgs::parse(arguments);
+        let args = DocsSlashCommandArgs::parse(&query);
         let store = args
             .provider()
             .ok_or_else(|| anyhow!("no docs provider specified"))
             .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
         cx.background_executor().spawn(async move {
-            fn build_completions(items: Vec<String>) -> Vec<ArgumentCompletion> {
+            fn build_completions(
+                provider: ProviderId,
+                items: Vec<String>,
+            ) -> Vec<ArgumentCompletion> {
                 items
                     .into_iter()
                     .map(|item| ArgumentCompletion {
-                        label: item.clone().into(),
-                        new_text: item.to_string(),
-                        after_completion: assistant_slash_command::AfterCompletion::Run,
-                        replace_previous_arguments: false,
+                        label: item.clone(),
+                        new_text: format!("{provider} {item}"),
+                        run_command: true,
                     })
                     .collect()
             }
@@ -192,20 +194,18 @@ impl SlashCommand for DocsSlashCommand {
                     let providers = indexed_docs_registry.list_providers();
                     if providers.is_empty() {
                         return Ok(vec![ArgumentCompletion {
-                            label: "No available docs providers.".into(),
+                            label: "No available docs providers.".to_string(),
                             new_text: String::new(),
-                            after_completion: false.into(),
-                            replace_previous_arguments: false,
+                            run_command: false,
                         }]);
                     }
 
                     Ok(providers
                         .into_iter()
                         .map(|provider| ArgumentCompletion {
-                            label: provider.to_string().into(),
+                            label: provider.to_string(),
                             new_text: provider.to_string(),
-                            after_completion: false.into(),
-                            replace_previous_arguments: false,
+                            run_command: false,
                         })
                         .collect())
                 }
@@ -222,45 +222,17 @@ impl SlashCommand for DocsSlashCommand {
                         drop(store.clone().index(package.as_str().into()));
                     }
 
-                    let suggested_packages = store.clone().suggest_packages().await?;
-                    let search_results = store.search(package).await;
-
-                    let mut items = build_completions(search_results);
-                    let workspace_crate_completions = suggested_packages
-                        .into_iter()
-                        .filter(|package_name| {
-                            !items
-                                .iter()
-                                .any(|item| item.label.text() == package_name.as_ref())
-                        })
-                        .map(|package_name| ArgumentCompletion {
-                            label: format!("{package_name} (unindexed)").into(),
-                            new_text: format!("{package_name}"),
-                            after_completion: true.into(),
-                            replace_previous_arguments: false,
-                        })
-                        .collect::<Vec<_>>();
-                    items.extend(workspace_crate_completions);
-
-                    if items.is_empty() {
-                        return Ok(vec![ArgumentCompletion {
-                            label: format!(
-                                "Enter a {package_term} name.",
-                                package_term = package_term(&provider)
-                            )
-                            .into(),
-                            new_text: provider.to_string(),
-                            after_completion: false.into(),
-                            replace_previous_arguments: false,
-                        }]);
-                    }
-
-                    Ok(items)
+                    let items = store.search(package).await;
+                    Ok(build_completions(provider, items))
                 }
-                DocsSlashCommandArgs::SearchItemDocs { item_path, .. } => {
+                DocsSlashCommandArgs::SearchItemDocs {
+                    provider,
+                    item_path,
+                    ..
+                } => {
                     let store = store?;
                     let items = store.search(item_path).await;
-                    Ok(build_completions(items))
+                    Ok(build_completions(provider, items))
                 }
             }
         })
@@ -268,16 +240,16 @@ impl SlashCommand for DocsSlashCommand {
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
     ) -> Task<Result<SlashCommandOutput>> {
-        if arguments.is_empty() {
-            return Task::ready(Err(anyhow!("missing an argument")));
+        let Some(argument) = argument else {
+            return Task::ready(Err(anyhow!("missing argument")));
         };
 
-        let args = DocsSlashCommandArgs::parse(arguments);
+        let args = DocsSlashCommandArgs::parse(argument);
         let executor = cx.background_executor().clone();
         let task = cx.background_executor().spawn({
             let store = args
@@ -297,13 +269,6 @@ impl SlashCommand for DocsSlashCommand {
                     } => (provider, item_path),
                 };
 
-                if key.trim().is_empty() {
-                    bail!(
-                        "no {package_term} name provided",
-                        package_term = package_term(&provider)
-                    );
-                }
-
                 let store = store?;
 
                 if let Some(package) = args.package() {
@@ -377,18 +342,12 @@ pub(crate) enum DocsSlashCommandArgs {
 }
 
 impl DocsSlashCommandArgs {
-    pub fn parse(arguments: &[String]) -> Self {
-        let Some(provider) = arguments
-            .get(0)
-            .cloned()
-            .filter(|arg| !arg.trim().is_empty())
-        else {
+    pub fn parse(argument: &str) -> Self {
+        let Some((provider, argument)) = argument.split_once(' ') else {
             return Self::NoProvider;
         };
+
         let provider = ProviderId(provider.into());
-        let Some(argument) = arguments.get(1) else {
-            return Self::NoProvider;
-        };
 
         if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) {
             if rest.trim().is_empty() {
@@ -432,15 +391,6 @@ impl DocsSlashCommandArgs {
     }
 }
 
-/// Returns the term used to refer to a package.
-fn package_term(provider: &ProviderId) -> &'static str {
-    if provider == &DocsDotRsProvider::id() || provider == &LocalRustdocProvider::id() {
-        return "crate";
-    }
-
-    "package"
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -448,16 +398,16 @@ mod tests {
     #[test]
     fn test_parse_docs_slash_command_args() {
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["".to_string()]),
+            DocsSlashCommandArgs::parse(""),
             DocsSlashCommandArgs::NoProvider
         );
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string()]),
+            DocsSlashCommandArgs::parse("rustdoc"),
             DocsSlashCommandArgs::NoProvider
         );
 
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string(), "".to_string()]),
+            DocsSlashCommandArgs::parse("rustdoc "),
             DocsSlashCommandArgs::SearchPackageDocs {
                 provider: ProviderId("rustdoc".into()),
                 package: "".into(),
@@ -465,7 +415,7 @@ mod tests {
             }
         );
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["gleam".to_string(), "".to_string()]),
+            DocsSlashCommandArgs::parse("gleam "),
             DocsSlashCommandArgs::SearchPackageDocs {
                 provider: ProviderId("gleam".into()),
                 package: "".into(),
@@ -474,7 +424,7 @@ mod tests {
         );
 
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string(), "gpui".to_string()]),
+            DocsSlashCommandArgs::parse("rustdoc gpui"),
             DocsSlashCommandArgs::SearchPackageDocs {
                 provider: ProviderId("rustdoc".into()),
                 package: "gpui".into(),
@@ -482,7 +432,7 @@ mod tests {
             }
         );
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["gleam".to_string(), "gleam_stdlib".to_string()]),
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib"),
             DocsSlashCommandArgs::SearchPackageDocs {
                 provider: ProviderId("gleam".into()),
                 package: "gleam_stdlib".into(),
@@ -492,7 +442,7 @@ mod tests {
 
         // Adding an item path delimiter indicates we can start indexing.
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["rustdoc".to_string(), "gpui:".to_string()]),
+            DocsSlashCommandArgs::parse("rustdoc gpui:"),
             DocsSlashCommandArgs::SearchPackageDocs {
                 provider: ProviderId("rustdoc".into()),
                 package: "gpui".into(),
@@ -500,7 +450,7 @@ mod tests {
             }
         );
         assert_eq!(
-            DocsSlashCommandArgs::parse(&["gleam".to_string(), "gleam_stdlib/".to_string()]),
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib/"),
             DocsSlashCommandArgs::SearchPackageDocs {
                 provider: ProviderId("gleam".into()),
                 package: "gleam_stdlib".into(),
@@ -509,10 +459,7 @@ mod tests {
         );
 
         assert_eq!(
-            DocsSlashCommandArgs::parse(&[
-                "rustdoc".to_string(),
-                "gpui::foo::bar::Baz".to_string()
-            ]),
+            DocsSlashCommandArgs::parse("rustdoc gpui::foo::bar::Baz"),
             DocsSlashCommandArgs::SearchItemDocs {
                 provider: ProviderId("rustdoc".into()),
                 package: "gpui".into(),
@@ -520,10 +467,7 @@ mod tests {
             }
         );
         assert_eq!(
-            DocsSlashCommandArgs::parse(&[
-                "gleam".to_string(),
-                "gleam_stdlib/gleam/int".to_string()
-            ]),
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib/gleam/int"),
             DocsSlashCommandArgs::SearchItemDocs {
                 provider: ProviderId("gleam".into()),
                 package: "gleam_stdlib".into(),

crates/assistant/src/slash_command/fetch_command.rs

@@ -8,7 +8,7 @@ use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
 };
 use futures::AsyncReadExt;
-use gpui::{Task, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use html_to_markdown::{convert_html_to_markdown, markdown, TagHandler};
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
 use language::LspAdapterDelegate;
@@ -117,22 +117,22 @@ impl SlashCommand for FetchSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Ok(Vec::new()))
     }
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
     ) -> Task<Result<SlashCommandOutput>> {
-        let Some(argument) = arguments.first() else {
+        let Some(argument) = argument else {
             return Task::ready(Err(anyhow!("missing URL")));
         };
         let Some(workspace) = workspace.upgrade() else {
@@ -150,10 +150,6 @@ impl SlashCommand for FetchSlashCommand {
         let url = SharedString::from(url);
         cx.foreground_executor().spawn(async move {
             let text = text.await?;
-            if text.trim().is_empty() {
-                bail!("no textual content found");
-            }
-
             let range = 0..text.len();
             Ok(SlashCommandOutput {
                 text,

crates/assistant/src/slash_command/file_command.rs

@@ -1,9 +1,9 @@
 use super::{diagnostics_command::write_single_file_diagnostics, SlashCommand, SlashCommandOutput};
-use anyhow::{anyhow, Context as _, Result};
-use assistant_slash_command::{AfterCompletion, ArgumentCompletion, SlashCommandOutputSection};
+use anyhow::{anyhow, Result};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use fuzzy::PathMatch;
 use gpui::{AppContext, Model, Task, View, WeakView};
-use language::{BufferSnapshot, CodeLabel, HighlightId, LineEnding, LspAdapterDelegate};
+use language::{BufferSnapshot, LineEnding, LspAdapterDelegate};
 use project::{PathMatchCandidateSet, Project};
 use std::{
     fmt::Write,
@@ -12,7 +12,7 @@ use std::{
     sync::{atomic::AtomicBool, Arc},
 };
 use ui::prelude::*;
-use util::ResultExt;
+use util::{paths::PathMatcher, ResultExt};
 use workspace::Workspace;
 
 pub(crate) struct FileSlashCommand;
@@ -29,30 +29,11 @@ impl FileSlashCommand {
             let workspace = workspace.read(cx);
             let project = workspace.project().read(cx);
             let entries = workspace.recent_navigation_history(Some(10), cx);
-
-            let entries = entries
-                .into_iter()
-                .map(|entries| (entries.0, false))
-                .chain(project.worktrees(cx).flat_map(|worktree| {
-                    let worktree = worktree.read(cx);
-                    let id = worktree.id();
-                    worktree.child_entries(Path::new("")).map(move |entry| {
-                        (
-                            project::ProjectPath {
-                                worktree_id: id,
-                                path: entry.path.clone(),
-                            },
-                            entry.kind.is_dir(),
-                        )
-                    })
-                }))
-                .collect::<Vec<_>>();
-
             let path_prefix: Arc<str> = Arc::default();
             Task::ready(
                 entries
                     .into_iter()
-                    .filter_map(|(entry, is_dir)| {
+                    .filter_map(|(entry, _)| {
                         let worktree = project.worktree_for_id(entry.worktree_id, cx)?;
                         let mut full_path = PathBuf::from(worktree.read(cx).root_name());
                         full_path.push(&entry.path);
@@ -63,7 +44,6 @@ impl FileSlashCommand {
                             path: full_path.into(),
                             path_prefix: path_prefix.clone(),
                             distance_to_relative_ancestor: 0,
-                            is_dir,
                         })
                     })
                     .collect(),
@@ -74,7 +54,6 @@ impl FileSlashCommand {
                 .into_iter()
                 .map(|worktree| {
                     let worktree = worktree.read(cx);
-
                     PathMatchCandidateSet {
                         snapshot: worktree.snapshot(),
                         include_ignored: worktree
@@ -122,55 +101,32 @@ impl SlashCommand for FileSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        arguments: &[String],
+        query: String,
         cancellation_flag: Arc<AtomicBool>,
         workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
+        cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         let Some(workspace) = workspace.and_then(|workspace| workspace.upgrade()) else {
             return Task::ready(Err(anyhow!("workspace was dropped")));
         };
 
-        let paths = self.search_paths(
-            arguments.last().cloned().unwrap_or_default(),
-            cancellation_flag,
-            &workspace,
-            cx,
-        );
-        let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
+        let paths = self.search_paths(query, cancellation_flag, &workspace, cx);
         cx.background_executor().spawn(async move {
             Ok(paths
                 .await
                 .into_iter()
-                .filter_map(|path_match| {
+                .map(|path_match| {
                     let text = format!(
                         "{}{}",
                         path_match.path_prefix,
                         path_match.path.to_string_lossy()
                     );
 
-                    let mut label = CodeLabel::default();
-                    let file_name = path_match.path.file_name()?.to_string_lossy();
-                    let label_text = if path_match.is_dir {
-                        format!("{}/ ", file_name)
-                    } else {
-                        format!("{} ", file_name)
-                    };
-
-                    label.push_str(label_text.as_str(), None);
-                    label.push_str(&text, comment_id);
-                    label.filter_range = 0..file_name.len();
-
-                    Some(ArgumentCompletion {
-                        label,
+                    ArgumentCompletion {
+                        label: text.clone(),
                         new_text: text,
-                        after_completion: if path_match.is_dir {
-                            AfterCompletion::Compose
-                        } else {
-                            AfterCompletion::Run
-                        },
-                        replace_previous_arguments: false,
-                    })
+                        run_command: true,
+                    }
                 })
                 .collect())
         })
@@ -178,7 +134,7 @@ impl SlashCommand for FileSlashCommand {
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -187,24 +143,23 @@ impl SlashCommand for FileSlashCommand {
             return Task::ready(Err(anyhow!("workspace was dropped")));
         };
 
-        if arguments.is_empty() {
+        let Some(argument) = argument else {
             return Task::ready(Err(anyhow!("missing path")));
         };
 
-        let task = collect_files(workspace.read(cx).project().clone(), arguments, cx);
+        let task = collect_files(workspace.read(cx).project().clone(), argument, cx);
 
         cx.foreground_executor().spawn(async move {
-            let output = task.await?;
+            let (text, ranges) = task.await?;
             Ok(SlashCommandOutput {
-                text: output.completion_text,
-                sections: output
-                    .files
+                text,
+                sections: ranges
                     .into_iter()
-                    .map(|file| {
+                    .map(|(range, path, entry_type)| {
                         build_entry_output_section(
-                            file.range_in_text,
-                            Some(&file.path),
-                            file.entry_type == EntryType::Directory,
+                            range,
+                            Some(&path),
+                            entry_type == EntryType::Directory,
                             None,
                         )
                     })
@@ -215,38 +170,18 @@ impl SlashCommand for FileSlashCommand {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Debug)]
+#[derive(Clone, Copy, PartialEq)]
 enum EntryType {
     File,
     Directory,
 }
 
-#[derive(Clone, PartialEq, Debug)]
-struct FileCommandOutput {
-    completion_text: String,
-    files: Vec<OutputFile>,
-}
-
-#[derive(Clone, PartialEq, Debug)]
-struct OutputFile {
-    range_in_text: Range<usize>,
-    path: PathBuf,
-    entry_type: EntryType,
-}
-
 fn collect_files(
     project: Model<Project>,
-    glob_inputs: &[String],
+    glob_input: &str,
     cx: &mut AppContext,
-) -> Task<Result<FileCommandOutput>> {
-    let Ok(matchers) = glob_inputs
-        .into_iter()
-        .map(|glob_input| {
-            custom_path_matcher::PathMatcher::new(&[glob_input.to_owned()])
-                .with_context(|| format!("invalid path {glob_input}"))
-        })
-        .collect::<anyhow::Result<Vec<custom_path_matcher::PathMatcher>>>()
-    else {
+) -> Task<Result<(String, Vec<(Range<usize>, PathBuf, EntryType)>)>> {
+    let Ok(matcher) = PathMatcher::new(&[glob_input.to_owned()]) else {
         return Task::ready(Err(anyhow!("invalid path")));
     };
 
@@ -256,7 +191,6 @@ fn collect_files(
         .worktrees(cx)
         .map(|worktree| worktree.read(cx).snapshot())
         .collect::<Vec<_>>();
-
     cx.spawn(|mut cx| async move {
         let mut text = String::new();
         let mut ranges = Vec::new();
@@ -265,16 +199,11 @@ fn collect_files(
             let mut directory_stack: Vec<(Arc<Path>, String, usize)> = Vec::new();
             let mut folded_directory_names_stack = Vec::new();
             let mut is_top_level_directory = true;
-
             for entry in snapshot.entries(false, 0) {
                 let mut path_including_worktree_name = PathBuf::new();
                 path_including_worktree_name.push(snapshot.root_name());
                 path_including_worktree_name.push(&entry.path);
-
-                if !matchers
-                    .iter()
-                    .any(|matcher| matcher.is_match(&path_including_worktree_name))
-                {
+                if !matcher.is_match(&path_including_worktree_name) {
                     continue;
                 }
 
@@ -283,11 +212,11 @@ fn collect_files(
                         break;
                     }
                     let (_, entry_name, start) = directory_stack.pop().unwrap();
-                    ranges.push(OutputFile {
-                        range_in_text: start..text.len().saturating_sub(1),
-                        path: PathBuf::from(entry_name),
-                        entry_type: EntryType::Directory,
-                    });
+                    ranges.push((
+                        start..text.len().saturating_sub(1),
+                        PathBuf::from(entry_name),
+                        EntryType::Directory,
+                    ));
                 }
 
                 let filename = entry
@@ -360,39 +289,24 @@ fn collect_files(
                         ) {
                             text.pop();
                         }
-                        ranges.push(OutputFile {
-                            range_in_text: prev_len..text.len(),
-                            path: path_including_worktree_name,
-                            entry_type: EntryType::File,
-                        });
+                        ranges.push((
+                            prev_len..text.len(),
+                            path_including_worktree_name,
+                            EntryType::File,
+                        ));
                         text.push('\n');
                     }
                 }
             }
 
-            while let Some((dir, entry, start)) = directory_stack.pop() {
-                if directory_stack.is_empty() {
-                    let mut root_path = PathBuf::new();
-                    root_path.push(snapshot.root_name());
-                    root_path.push(&dir);
-                    ranges.push(OutputFile {
-                        range_in_text: start..text.len(),
-                        path: root_path,
-                        entry_type: EntryType::Directory,
-                    });
-                } else {
-                    ranges.push(OutputFile {
-                        range_in_text: start..text.len(),
-                        path: PathBuf::from(entry.as_str()),
-                        entry_type: EntryType::Directory,
-                    });
-                }
+            while let Some((dir, _, start)) = directory_stack.pop() {
+                let mut root_path = PathBuf::new();
+                root_path.push(snapshot.root_name());
+                root_path.push(&dir);
+                ranges.push((start..text.len(), root_path, EntryType::Directory));
             }
         }
-        Ok(FileCommandOutput {
-            completion_text: text,
-            files: ranges,
-        })
+        Ok((text, ranges))
     })
 }
 
@@ -460,300 +374,3 @@ pub fn build_entry_output_section(
         label: label.into(),
     }
 }
-
-/// This contains a small fork of the util::paths::PathMatcher, that is stricter about the prefix
-/// check. Only subpaths pass the prefix check, rather than any prefix.
-mod custom_path_matcher {
-    use std::{fmt::Debug as _, path::Path};
-
-    use globset::{Glob, GlobSet, GlobSetBuilder};
-
-    #[derive(Clone, Debug, Default)]
-    pub struct PathMatcher {
-        sources: Vec<String>,
-        sources_with_trailing_slash: Vec<String>,
-        glob: GlobSet,
-    }
-
-    impl std::fmt::Display for PathMatcher {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            self.sources.fmt(f)
-        }
-    }
-
-    impl PartialEq for PathMatcher {
-        fn eq(&self, other: &Self) -> bool {
-            self.sources.eq(&other.sources)
-        }
-    }
-
-    impl Eq for PathMatcher {}
-
-    impl PathMatcher {
-        pub fn new(globs: &[String]) -> Result<Self, globset::Error> {
-            let globs = globs
-                .into_iter()
-                .map(|glob| Glob::new(&glob))
-                .collect::<Result<Vec<_>, _>>()?;
-            let sources = globs.iter().map(|glob| glob.glob().to_owned()).collect();
-            let sources_with_trailing_slash = globs
-                .iter()
-                .map(|glob| glob.glob().to_string() + std::path::MAIN_SEPARATOR_STR)
-                .collect();
-            let mut glob_builder = GlobSetBuilder::new();
-            for single_glob in globs {
-                glob_builder.add(single_glob);
-            }
-            let glob = glob_builder.build()?;
-            Ok(PathMatcher {
-                glob,
-                sources,
-                sources_with_trailing_slash,
-            })
-        }
-
-        pub fn sources(&self) -> &[String] {
-            &self.sources
-        }
-
-        pub fn is_match<P: AsRef<Path>>(&self, other: P) -> bool {
-            let other_path = other.as_ref();
-            self.sources
-                .iter()
-                .zip(self.sources_with_trailing_slash.iter())
-                .any(|(source, with_slash)| {
-                    let as_bytes = other_path.as_os_str().as_encoded_bytes();
-                    let with_slash = if source.ends_with("/") {
-                        source.as_bytes()
-                    } else {
-                        with_slash.as_bytes()
-                    };
-
-                    as_bytes.starts_with(with_slash) || as_bytes.ends_with(source.as_bytes())
-                })
-                || self.glob.is_match(other_path)
-                || self.check_with_end_separator(other_path)
-        }
-
-        fn check_with_end_separator(&self, path: &Path) -> bool {
-            let path_str = path.to_string_lossy();
-            let separator = std::path::MAIN_SEPARATOR_STR;
-            if path_str.ends_with(separator) {
-                return false;
-            } else {
-                self.glob.is_match(path_str.to_string() + separator)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use fs::FakeFs;
-    use gpui::TestAppContext;
-    use project::Project;
-    use serde_json::json;
-    use settings::SettingsStore;
-
-    use crate::slash_command::file_command::collect_files;
-
-    pub fn init_test(cx: &mut gpui::TestAppContext) {
-        if std::env::var("RUST_LOG").is_ok() {
-            env_logger::try_init().ok();
-        }
-
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            // release_channel::init(SemanticVersion::default(), cx);
-            language::init(cx);
-            Project::init_settings(cx);
-        });
-    }
-
-    #[gpui::test]
-    async fn test_file_exact_matching(cx: &mut TestAppContext) {
-        init_test(cx);
-        let fs = FakeFs::new(cx.executor());
-
-        fs.insert_tree(
-            "/root",
-            json!({
-                "dir": {
-                    "subdir": {
-                       "file_0": "0"
-                    },
-                    "file_1": "1",
-                    "file_2": "2",
-                    "file_3": "3",
-                },
-                "dir.rs": "4"
-            }),
-        )
-        .await;
-
-        let project = Project::test(fs, ["/root".as_ref()], cx).await;
-
-        let result_1 = cx
-            .update(|cx| collect_files(project.clone(), &["root/dir".to_string()], cx))
-            .await
-            .unwrap();
-
-        assert!(result_1.completion_text.starts_with("root/dir"));
-        // 4 files + 2 directories
-        assert_eq!(6, result_1.files.len());
-
-        let result_2 = cx
-            .update(|cx| collect_files(project.clone(), &["root/dir/".to_string()], cx))
-            .await
-            .unwrap();
-
-        assert_eq!(result_1, result_2);
-
-        let result = cx
-            .update(|cx| collect_files(project.clone(), &["root/dir*".to_string()], cx))
-            .await
-            .unwrap();
-
-        assert!(result.completion_text.starts_with("root/dir"));
-        // 5 files + 2 directories
-        assert_eq!(7, result.files.len());
-
-        // Ensure that the project lasts until after the last await
-        drop(project);
-    }
-
-    #[gpui::test]
-    async fn test_file_sub_directory_rendering(cx: &mut TestAppContext) {
-        init_test(cx);
-        let fs = FakeFs::new(cx.executor());
-
-        fs.insert_tree(
-            "/zed",
-            json!({
-                "assets": {
-                    "dir1": {
-                        ".gitkeep": ""
-                    },
-                    "dir2": {
-                        ".gitkeep": ""
-                    },
-                    "themes": {
-                        "ayu": {
-                            "LICENSE": "1",
-                        },
-                        "andromeda": {
-                            "LICENSE": "2",
-                        },
-                        "summercamp": {
-                            "LICENSE": "3",
-                        },
-                    },
-                },
-            }),
-        )
-        .await;
-
-        let project = Project::test(fs, ["/zed".as_ref()], cx).await;
-
-        let result = cx
-            .update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx))
-            .await
-            .unwrap();
-
-        // Sanity check
-        assert!(result.completion_text.starts_with("zed/assets/themes\n"));
-        assert_eq!(7, result.files.len());
-
-        // Ensure that full file paths are included in the real output
-        assert!(result
-            .completion_text
-            .contains("zed/assets/themes/andromeda/LICENSE"));
-        assert!(result
-            .completion_text
-            .contains("zed/assets/themes/ayu/LICENSE"));
-        assert!(result
-            .completion_text
-            .contains("zed/assets/themes/summercamp/LICENSE"));
-
-        assert_eq!("summercamp", result.files[5].path.to_string_lossy());
-
-        // Ensure that things are in descending order, with properly relativized paths
-        assert_eq!(
-            "zed/assets/themes/andromeda/LICENSE",
-            result.files[0].path.to_string_lossy()
-        );
-        assert_eq!("andromeda", result.files[1].path.to_string_lossy());
-        assert_eq!(
-            "zed/assets/themes/ayu/LICENSE",
-            result.files[2].path.to_string_lossy()
-        );
-        assert_eq!("ayu", result.files[3].path.to_string_lossy());
-        assert_eq!(
-            "zed/assets/themes/summercamp/LICENSE",
-            result.files[4].path.to_string_lossy()
-        );
-
-        // Ensure that the project lasts until after the last await
-        drop(project);
-    }
-
-    #[gpui::test]
-    async fn test_file_deep_sub_directory_rendering(cx: &mut TestAppContext) {
-        init_test(cx);
-        let fs = FakeFs::new(cx.executor());
-
-        fs.insert_tree(
-            "/zed",
-            json!({
-                "assets": {
-                    "themes": {
-                        "LICENSE": "1",
-                        "summercamp": {
-                            "LICENSE": "1",
-                            "subdir": {
-                                "LICENSE": "1",
-                                "subsubdir": {
-                                    "LICENSE": "3",
-                                }
-                            }
-                        },
-                    },
-                },
-            }),
-        )
-        .await;
-
-        let project = Project::test(fs, ["/zed".as_ref()], cx).await;
-
-        let result = cx
-            .update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx))
-            .await
-            .unwrap();
-
-        assert!(result.completion_text.starts_with("zed/assets/themes\n"));
-        assert_eq!(
-            "zed/assets/themes/LICENSE",
-            result.files[0].path.to_string_lossy()
-        );
-        assert_eq!(
-            "zed/assets/themes/summercamp/LICENSE",
-            result.files[1].path.to_string_lossy()
-        );
-        assert_eq!(
-            "zed/assets/themes/summercamp/subdir/LICENSE",
-            result.files[2].path.to_string_lossy()
-        );
-        assert_eq!(
-            "zed/assets/themes/summercamp/subdir/subsubdir/LICENSE",
-            result.files[3].path.to_string_lossy()
-        );
-        assert_eq!("subsubdir", result.files[4].path.to_string_lossy());
-        assert_eq!("subdir", result.files[5].path.to_string_lossy());
-        assert_eq!("summercamp", result.files[6].path.to_string_lossy());
-        assert_eq!("zed/assets/themes", result.files[7].path.to_string_lossy());
-
-        // Ensure that the project lasts until after the last await
-        drop(project);
-    }
-}

crates/assistant/src/slash_command/now_command.rs

@@ -6,7 +6,7 @@ use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
 };
 use chrono::Local;
-use gpui::{Task, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use ui::prelude::*;
 use workspace::Workspace;
@@ -32,17 +32,17 @@ impl SlashCommand for NowSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Ok(Vec::new()))
     }
 
     fn run(
         self: Arc<Self>,
-        _arguments: &[String],
+        _argument: Option<&str>,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         _cx: &mut WindowContext,

crates/assistant/src/slash_command/project_command.rs

@@ -103,10 +103,10 @@ impl SlashCommand for ProjectSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Err(anyhow!("this command does not require argument")))
     }
@@ -117,7 +117,7 @@ impl SlashCommand for ProjectSlashCommand {
 
     fn run(
         self: Arc<Self>,
-        _arguments: &[String],
+        _argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,

crates/assistant/src/slash_command/prompt_command.rs

@@ -2,7 +2,7 @@ use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Context, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
-use gpui::{Task, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::sync::{atomic::AtomicBool, Arc};
 use ui::prelude::*;
@@ -29,13 +29,12 @@ impl SlashCommand for PromptSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        arguments: &[String],
+        query: String,
         _cancellation_flag: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
+        cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         let store = PromptStore::global(cx);
-        let query = arguments.to_owned().join(" ");
         cx.background_executor().spawn(async move {
             let prompts = store.await?.search(query).await;
             Ok(prompts
@@ -43,10 +42,9 @@ impl SlashCommand for PromptSlashCommand {
                 .filter_map(|prompt| {
                     let prompt_title = prompt.title?.to_string();
                     Some(ArgumentCompletion {
-                        label: prompt_title.clone().into(),
+                        label: prompt_title.clone(),
                         new_text: prompt_title,
-                        after_completion: true.into(),
-                        replace_previous_arguments: true,
+                        run_command: true,
                     })
                 })
                 .collect())
@@ -55,18 +53,17 @@ impl SlashCommand for PromptSlashCommand {
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        title: Option<&str>,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
     ) -> Task<Result<SlashCommandOutput>> {
-        let title = arguments.to_owned().join(" ");
-        if title.trim().is_empty() {
+        let Some(title) = title else {
             return Task::ready(Err(anyhow!("missing prompt name")));
         };
 
         let store = PromptStore::global(cx);
-        let title = SharedString::from(title.clone());
+        let title = SharedString::from(title.to_string());
         let prompt = cx.background_executor().spawn({
             let title = title.clone();
             async move {
@@ -80,11 +77,6 @@ impl SlashCommand for PromptSlashCommand {
         });
         cx.foreground_executor().spawn(async move {
             let mut prompt = prompt.await?;
-
-            if prompt.starts_with('/') {
-                // Prevent an edge case where the inserted prompt starts with a slash command (that leads to funky rendering).
-                prompt.insert(0, '\n');
-            }
             if prompt.is_empty() {
                 prompt.push('\n');
             }

crates/assistant/src/slash_command/search_command.rs

@@ -5,7 +5,6 @@ use super::{
 };
 use anyhow::Result;
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
-use feature_flags::FeatureFlag;
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LineEnding, LspAdapterDelegate};
 use semantic_index::SemanticIndex;
@@ -18,12 +17,6 @@ use ui::{prelude::*, IconName};
 use util::ResultExt;
 use workspace::Workspace;
 
-pub(crate) struct SearchSlashCommandFeatureFlag;
-
-impl FeatureFlag for SearchSlashCommandFeatureFlag {
-    const NAME: &'static str = "search-slash-command";
-}
-
 pub(crate) struct SearchSlashCommand;
 
 impl SlashCommand for SearchSlashCommand {
@@ -49,17 +42,17 @@ impl SlashCommand for SearchSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Ok(Vec::new()))
     }
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -67,13 +60,13 @@ impl SlashCommand for SearchSlashCommand {
         let Some(workspace) = workspace.upgrade() else {
             return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
         };
-        if arguments.is_empty() {
+        let Some(argument) = argument else {
             return Task::ready(Err(anyhow::anyhow!("missing search query")));
         };
 
         let mut limit = None;
         let mut query = String::new();
-        for part in arguments {
+        for part in argument.split(' ') {
             if let Some(parameter) = part.strip_prefix("--") {
                 if let Ok(count) = parameter.parse::<usize>() {
                     limit = Some(count);

crates/assistant/src/slash_command/symbols_command.rs

@@ -2,7 +2,7 @@ use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use editor::Editor;
-use gpui::{Task, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::sync::Arc;
 use std::{path::Path, sync::atomic::AtomicBool};
@@ -26,10 +26,10 @@ impl SlashCommand for OutlineSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Err(anyhow!("this command does not require argument")))
     }
@@ -40,7 +40,7 @@ impl SlashCommand for OutlineSlashCommand {
 
     fn run(
         self: Arc<Self>,
-        _arguments: &[String],
+        _argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,

crates/assistant/src/slash_command/tab_command.rs

@@ -1,318 +0,0 @@
-use super::{
-    diagnostics_command::write_single_file_diagnostics,
-    file_command::{build_entry_output_section, codeblock_fence_for_path},
-    SlashCommand, SlashCommandOutput,
-};
-use anyhow::{Context, Result};
-use assistant_slash_command::ArgumentCompletion;
-use collections::{HashMap, HashSet};
-use editor::Editor;
-use futures::future::join_all;
-use gpui::{Entity, Task, WeakView};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use std::{
-    fmt::Write,
-    path::PathBuf,
-    sync::{atomic::AtomicBool, Arc},
-};
-use ui::WindowContext;
-use workspace::Workspace;
-
-pub(crate) struct TabSlashCommand;
-
-const ALL_TABS_COMPLETION_ITEM: &str = "all";
-
-impl SlashCommand for TabSlashCommand {
-    fn name(&self) -> String {
-        "tab".into()
-    }
-
-    fn description(&self) -> String {
-        "insert open tabs (active tab by default)".to_owned()
-    }
-
-    fn menu_text(&self) -> String {
-        "Insert Open Tabs".to_owned()
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
-    }
-
-    fn accepts_arguments(&self) -> bool {
-        true
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        arguments: &[String],
-        cancel: Arc<AtomicBool>,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        let mut has_all_tabs_completion_item = false;
-        let argument_set = arguments
-            .iter()
-            .filter(|argument| {
-                if has_all_tabs_completion_item || ALL_TABS_COMPLETION_ITEM == argument.as_str() {
-                    has_all_tabs_completion_item = true;
-                    false
-                } else {
-                    true
-                }
-            })
-            .cloned()
-            .collect::<HashSet<_>>();
-        if has_all_tabs_completion_item {
-            return Task::ready(Ok(Vec::new()));
-        }
-
-        let active_item_path = workspace.as_ref().and_then(|workspace| {
-            workspace
-                .update(cx, |workspace, cx| {
-                    let snapshot = active_item_buffer(workspace, cx).ok()?;
-                    snapshot.resolve_file_path(cx, true)
-                })
-                .ok()
-                .flatten()
-        });
-        let current_query = arguments.last().cloned().unwrap_or_default();
-        let tab_items_search =
-            tab_items_for_queries(workspace, &[current_query], cancel, false, cx);
-        cx.spawn(|_| async move {
-            let tab_items = tab_items_search.await?;
-            let run_command = tab_items.len() == 1;
-            let tab_completion_items = tab_items.into_iter().filter_map(|(path, ..)| {
-                let path_string = path.as_deref()?.to_string_lossy().to_string();
-                if argument_set.contains(&path_string) {
-                    return None;
-                }
-                if active_item_path.is_some() && active_item_path == path {
-                    return None;
-                }
-                Some(ArgumentCompletion {
-                    label: path_string.clone().into(),
-                    new_text: path_string,
-                    replace_previous_arguments: false,
-                    after_completion: run_command.into(),
-                })
-            });
-
-            let active_item_completion = active_item_path
-                .as_deref()
-                .map(|active_item_path| active_item_path.to_string_lossy().to_string())
-                .filter(|path_string| !argument_set.contains(path_string))
-                .map(|path_string| ArgumentCompletion {
-                    label: path_string.clone().into(),
-                    new_text: path_string,
-                    replace_previous_arguments: false,
-                    after_completion: run_command.into(),
-                });
-
-            Ok(active_item_completion
-                .into_iter()
-                .chain(Some(ArgumentCompletion {
-                    label: ALL_TABS_COMPLETION_ITEM.into(),
-                    new_text: ALL_TABS_COMPLETION_ITEM.to_owned(),
-                    replace_previous_arguments: false,
-                    after_completion: true.into(),
-                }))
-                .chain(tab_completion_items)
-                .collect())
-        })
-    }
-
-    fn run(
-        self: Arc<Self>,
-        arguments: &[String],
-        workspace: WeakView<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<SlashCommandOutput>> {
-        let tab_items_search = tab_items_for_queries(
-            Some(workspace),
-            arguments,
-            Arc::new(AtomicBool::new(false)),
-            true,
-            cx,
-        );
-
-        cx.background_executor().spawn(async move {
-            let mut sections = Vec::new();
-            let mut text = String::new();
-            let mut has_diagnostics = false;
-            for (full_path, buffer, _) in tab_items_search.await? {
-                let section_start_ix = text.len();
-                text.push_str(&codeblock_fence_for_path(full_path.as_deref(), None));
-                for chunk in buffer.as_rope().chunks() {
-                    text.push_str(chunk);
-                }
-                if !text.ends_with('\n') {
-                    text.push('\n');
-                }
-                writeln!(text, "```").unwrap();
-                if write_single_file_diagnostics(&mut text, full_path.as_deref(), &buffer) {
-                    has_diagnostics = true;
-                }
-                if !text.ends_with('\n') {
-                    text.push('\n');
-                }
-
-                let section_end_ix = text.len() - 1;
-                sections.push(build_entry_output_section(
-                    section_start_ix..section_end_ix,
-                    full_path.as_deref(),
-                    false,
-                    None,
-                ));
-            }
-
-            Ok(SlashCommandOutput {
-                text,
-                sections,
-                run_commands_in_text: has_diagnostics,
-            })
-        })
-    }
-}
-
-fn tab_items_for_queries(
-    workspace: Option<WeakView<Workspace>>,
-    queries: &[String],
-    cancel: Arc<AtomicBool>,
-    strict_match: bool,
-    cx: &mut WindowContext,
-) -> Task<anyhow::Result<Vec<(Option<PathBuf>, BufferSnapshot, usize)>>> {
-    let empty_query = queries.is_empty() || queries.iter().all(|query| query.trim().is_empty());
-    let queries = queries.to_owned();
-    cx.spawn(|mut cx| async move {
-        let mut open_buffers =
-            workspace
-                .context("no workspace")?
-                .update(&mut cx, |workspace, cx| {
-                    if strict_match && empty_query {
-                        let snapshot = active_item_buffer(workspace, cx)?;
-                        let full_path = snapshot.resolve_file_path(cx, true);
-                        return anyhow::Ok(vec![(full_path, snapshot, 0)]);
-                    }
-
-                    let mut timestamps_by_entity_id = HashMap::default();
-                    let mut open_buffers = Vec::new();
-
-                    for pane in workspace.panes() {
-                        let pane = pane.read(cx);
-                        for entry in pane.activation_history() {
-                            timestamps_by_entity_id.insert(entry.entity_id, entry.timestamp);
-                        }
-                    }
-
-                    for editor in workspace.items_of_type::<Editor>(cx) {
-                        if let Some(buffer) = editor.read(cx).buffer().read(cx).as_singleton() {
-                            if let Some(timestamp) =
-                                timestamps_by_entity_id.get(&editor.entity_id())
-                            {
-                                let snapshot = buffer.read(cx).snapshot();
-                                let full_path = snapshot.resolve_file_path(cx, true);
-                                open_buffers.push((full_path, snapshot, *timestamp));
-                            }
-                        }
-                    }
-
-                    Ok(open_buffers)
-                })??;
-
-        let background_executor = cx.background_executor().clone();
-        cx.background_executor()
-            .spawn(async move {
-                open_buffers.sort_by_key(|(_, _, timestamp)| *timestamp);
-                if empty_query
-                    || queries
-                        .iter()
-                        .any(|query| query == ALL_TABS_COMPLETION_ITEM)
-                {
-                    return Ok(open_buffers);
-                }
-
-                let matched_items = if strict_match {
-                    let match_candidates = open_buffers
-                        .iter()
-                        .enumerate()
-                        .filter_map(|(id, (full_path, ..))| {
-                            let path_string = full_path.as_deref()?.to_string_lossy().to_string();
-                            Some((id, path_string))
-                        })
-                        .fold(HashMap::default(), |mut candidates, (id, path_string)| {
-                            candidates
-                                .entry(path_string)
-                                .or_insert_with(|| Vec::new())
-                                .push(id);
-                            candidates
-                        });
-
-                    queries
-                        .iter()
-                        .filter_map(|query| match_candidates.get(query))
-                        .flatten()
-                        .copied()
-                        .filter_map(|id| open_buffers.get(id))
-                        .cloned()
-                        .collect()
-                } else {
-                    let match_candidates = open_buffers
-                        .iter()
-                        .enumerate()
-                        .filter_map(|(id, (full_path, ..))| {
-                            let path_string = full_path.as_deref()?.to_string_lossy().to_string();
-                            Some(fuzzy::StringMatchCandidate {
-                                id,
-                                char_bag: path_string.as_str().into(),
-                                string: path_string,
-                            })
-                        })
-                        .collect::<Vec<_>>();
-                    let mut processed_matches = HashSet::default();
-                    let file_queries = queries.iter().map(|query| {
-                        fuzzy::match_strings(
-                            &match_candidates,
-                            query,
-                            true,
-                            usize::MAX,
-                            &cancel,
-                            background_executor.clone(),
-                        )
-                    });
-
-                    join_all(file_queries)
-                        .await
-                        .into_iter()
-                        .flatten()
-                        .filter(|string_match| processed_matches.insert(string_match.candidate_id))
-                        .filter_map(|string_match| open_buffers.get(string_match.candidate_id))
-                        .cloned()
-                        .collect()
-                };
-                Ok(matched_items)
-            })
-            .await
-    })
-}
-
-fn active_item_buffer(
-    workspace: &mut Workspace,
-    cx: &mut ui::ViewContext<Workspace>,
-) -> anyhow::Result<BufferSnapshot> {
-    let active_editor = workspace
-        .active_item(cx)
-        .context("no active item")?
-        .downcast::<Editor>()
-        .context("active item is not an editor")?;
-    let snapshot = active_editor
-        .read(cx)
-        .buffer()
-        .read(cx)
-        .as_singleton()
-        .context("active editor is not a singleton buffer")?
-        .read(cx)
-        .snapshot();
-    Ok(snapshot)
-}

crates/assistant/src/slash_command/tabs_command.rs

@@ -0,0 +1,118 @@
+use super::{
+    diagnostics_command::write_single_file_diagnostics,
+    file_command::{build_entry_output_section, codeblock_fence_for_path},
+    SlashCommand, SlashCommandOutput,
+};
+use anyhow::{anyhow, Result};
+use assistant_slash_command::ArgumentCompletion;
+use collections::HashMap;
+use editor::Editor;
+use gpui::{AppContext, Entity, Task, WeakView};
+use language::LspAdapterDelegate;
+use std::{fmt::Write, sync::Arc};
+use ui::WindowContext;
+use workspace::Workspace;
+
+pub(crate) struct TabsSlashCommand;
+
+impl SlashCommand for TabsSlashCommand {
+    fn name(&self) -> String {
+        "tabs".into()
+    }
+
+    fn description(&self) -> String {
+        "insert open tabs".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Open Tabs".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _query: String,
+        _cancel: Arc<std::sync::atomic::AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut AppContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Err(anyhow!("this command does not require argument")))
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _argument: Option<&str>,
+        workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let open_buffers = workspace.update(cx, |workspace, cx| {
+            let mut timestamps_by_entity_id = HashMap::default();
+            let mut open_buffers = Vec::new();
+
+            for pane in workspace.panes() {
+                let pane = pane.read(cx);
+                for entry in pane.activation_history() {
+                    timestamps_by_entity_id.insert(entry.entity_id, entry.timestamp);
+                }
+            }
+
+            for editor in workspace.items_of_type::<Editor>(cx) {
+                if let Some(buffer) = editor.read(cx).buffer().read(cx).as_singleton() {
+                    if let Some(timestamp) = timestamps_by_entity_id.get(&editor.entity_id()) {
+                        let snapshot = buffer.read(cx).snapshot();
+                        let full_path = snapshot.resolve_file_path(cx, true);
+                        open_buffers.push((full_path, snapshot, *timestamp));
+                    }
+                }
+            }
+
+            open_buffers
+        });
+
+        match open_buffers {
+            Ok(mut open_buffers) => cx.background_executor().spawn(async move {
+                open_buffers.sort_by_key(|(_, _, timestamp)| *timestamp);
+
+                let mut sections = Vec::new();
+                let mut text = String::new();
+                let mut has_diagnostics = false;
+                for (full_path, buffer, _) in open_buffers {
+                    let section_start_ix = text.len();
+                    text.push_str(&codeblock_fence_for_path(full_path.as_deref(), None));
+                    for chunk in buffer.as_rope().chunks() {
+                        text.push_str(chunk);
+                    }
+                    if !text.ends_with('\n') {
+                        text.push('\n');
+                    }
+                    writeln!(text, "```").unwrap();
+                    if write_single_file_diagnostics(&mut text, full_path.as_deref(), &buffer) {
+                        has_diagnostics = true;
+                    }
+                    if !text.ends_with('\n') {
+                        text.push('\n');
+                    }
+
+                    let section_end_ix = text.len() - 1;
+                    sections.push(build_entry_output_section(
+                        section_start_ix..section_end_ix,
+                        full_path.as_deref(),
+                        false,
+                        None,
+                    ));
+                }
+
+                Ok(SlashCommandOutput {
+                    text,
+                    sections,
+                    run_commands_in_text: has_diagnostics,
+                })
+            }),
+            Err(error) => Task::ready(Err(error)),
+        }
+    }
+}

crates/assistant/src/slash_command/term_command.rs

@@ -5,7 +5,7 @@ use anyhow::Result;
 use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
 };
-use gpui::{AppContext, Task, View, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LspAdapterDelegate};
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
 use ui::prelude::*;
@@ -15,17 +15,17 @@ use crate::DEFAULT_CONTEXT_LINES;
 
 use super::create_label_for_command;
 
-pub(crate) struct TerminalSlashCommand;
+pub(crate) struct TermSlashCommand;
 
 const LINE_COUNT_ARG: &str = "--line-count";
 
-impl SlashCommand for TerminalSlashCommand {
+impl SlashCommand for TermSlashCommand {
     fn name(&self) -> String {
-        "terminal".into()
+        "term".into()
     }
 
     fn label(&self, cx: &AppContext) -> CodeLabel {
-        create_label_for_command("terminal", &[LINE_COUNT_ARG], cx)
+        create_label_for_command("term", &[LINE_COUNT_ARG], cx)
     }
 
     fn description(&self) -> String {
@@ -40,23 +40,23 @@ impl SlashCommand for TerminalSlashCommand {
         false
     }
 
-    fn accepts_arguments(&self) -> bool {
-        true
-    }
-
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Ok(Vec::new()))
+        Task::ready(Ok(vec![ArgumentCompletion {
+            label: LINE_COUNT_ARG.to_string(),
+            new_text: LINE_COUNT_ARG.to_string(),
+            run_command: true,
+        }]))
     }
 
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -64,14 +64,19 @@ impl SlashCommand for TerminalSlashCommand {
         let Some(workspace) = workspace.upgrade() else {
             return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
         };
-
-        let Some(active_terminal) = resolve_active_terminal(&workspace, cx) else {
+        let Some(terminal_panel) = workspace.read(cx).panel::<TerminalPanel>(cx) else {
+            return Task::ready(Err(anyhow::anyhow!("no terminal panel open")));
+        };
+        let Some(active_terminal) = terminal_panel.read(cx).pane().and_then(|pane| {
+            pane.read(cx)
+                .active_item()
+                .and_then(|t| t.downcast::<TerminalView>())
+        }) else {
             return Task::ready(Err(anyhow::anyhow!("no active terminal")));
         };
 
-        let line_count = arguments
-            .get(0)
-            .and_then(|s| s.parse::<usize>().ok())
+        let line_count = argument
+            .and_then(|a| parse_argument(a))
             .unwrap_or(DEFAULT_CONTEXT_LINES);
 
         let lines = active_terminal
@@ -97,22 +102,12 @@ impl SlashCommand for TerminalSlashCommand {
     }
 }
 
-fn resolve_active_terminal(
-    workspace: &View<Workspace>,
-    cx: &WindowContext,
-) -> Option<View<TerminalView>> {
-    if let Some(terminal_view) = workspace
-        .read(cx)
-        .active_item(cx)
-        .and_then(|item| item.act_as::<TerminalView>(cx))
-    {
-        return Some(terminal_view);
+fn parse_argument(argument: &str) -> Option<usize> {
+    let mut args = argument.split(' ');
+    if args.next() == Some(LINE_COUNT_ARG) {
+        if let Some(line_count) = args.next().and_then(|s| s.parse::<usize>().ok()) {
+            return Some(line_count);
+        }
     }
-
-    let terminal_panel = workspace.read(cx).panel::<TerminalPanel>(cx)?;
-    terminal_panel.read(cx).pane().and_then(|pane| {
-        pane.read(cx)
-            .active_item()
-            .and_then(|t| t.downcast::<TerminalView>())
-    })
+    None
 }

crates/assistant/src/slash_command/workflow_command.rs

@@ -7,7 +7,7 @@ use anyhow::Result;
 use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
 };
-use gpui::{Task, WeakView};
+use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use ui::prelude::*;
 
@@ -42,17 +42,17 @@ impl SlashCommand for WorkflowSlashCommand {
 
     fn complete_argument(
         self: Arc<Self>,
-        _arguments: &[String],
+        _query: String,
         _cancel: Arc<AtomicBool>,
         _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
+        _cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
         Task::ready(Ok(Vec::new()))
     }
 
     fn run(
         self: Arc<Self>,
-        _arguments: &[String],
+        _argument: Option<&str>,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,

crates/assistant/src/slash_command_picker.rs

@@ -1,306 +0,0 @@
-use std::sync::Arc;
-
-use assistant_slash_command::SlashCommandRegistry;
-use gpui::AnyElement;
-use gpui::DismissEvent;
-use gpui::WeakView;
-use picker::PickerEditorPosition;
-
-use ui::ListItemSpacing;
-
-use gpui::SharedString;
-use gpui::Task;
-use picker::{Picker, PickerDelegate};
-use ui::{prelude::*, ListItem, PopoverMenu, PopoverTrigger};
-
-use crate::assistant_panel::ContextEditor;
-
-#[derive(IntoElement)]
-pub(super) struct SlashCommandSelector<T: PopoverTrigger> {
-    registry: Arc<SlashCommandRegistry>,
-    active_context_editor: WeakView<ContextEditor>,
-    trigger: T,
-}
-
-#[derive(Clone)]
-struct SlashCommandInfo {
-    name: SharedString,
-    description: SharedString,
-    args: Option<SharedString>,
-}
-
-#[derive(Clone)]
-enum SlashCommandEntry {
-    Info(SlashCommandInfo),
-    Advert {
-        name: SharedString,
-        renderer: fn(&mut WindowContext<'_>) -> AnyElement,
-        on_confirm: fn(&mut WindowContext<'_>),
-    },
-}
-
-impl AsRef<str> for SlashCommandEntry {
-    fn as_ref(&self) -> &str {
-        match self {
-            SlashCommandEntry::Info(SlashCommandInfo { name, .. })
-            | SlashCommandEntry::Advert { name, .. } => name,
-        }
-    }
-}
-
-pub(crate) struct SlashCommandDelegate {
-    all_commands: Vec<SlashCommandEntry>,
-    filtered_commands: Vec<SlashCommandEntry>,
-    active_context_editor: WeakView<ContextEditor>,
-    selected_index: usize,
-}
-
-impl<T: PopoverTrigger> SlashCommandSelector<T> {
-    pub(crate) fn new(
-        registry: Arc<SlashCommandRegistry>,
-        active_context_editor: WeakView<ContextEditor>,
-        trigger: T,
-    ) -> Self {
-        SlashCommandSelector {
-            registry,
-            active_context_editor,
-            trigger,
-        }
-    }
-}
-
-impl PickerDelegate for SlashCommandDelegate {
-    type ListItem = ListItem;
-
-    fn match_count(&self) -> usize {
-        self.filtered_commands.len()
-    }
-
-    fn selected_index(&self) -> usize {
-        self.selected_index
-    }
-
-    fn set_selected_index(&mut self, ix: usize, cx: &mut ViewContext<Picker<Self>>) {
-        self.selected_index = ix.min(self.filtered_commands.len().saturating_sub(1));
-        cx.notify();
-    }
-
-    fn placeholder_text(&self, _cx: &mut WindowContext) -> Arc<str> {
-        "Select a command...".into()
-    }
-
-    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
-        let all_commands = self.all_commands.clone();
-        cx.spawn(|this, mut cx| async move {
-            let filtered_commands = cx
-                .background_executor()
-                .spawn(async move {
-                    if query.is_empty() {
-                        all_commands
-                    } else {
-                        all_commands
-                            .into_iter()
-                            .filter(|model_info| {
-                                model_info
-                                    .as_ref()
-                                    .to_lowercase()
-                                    .contains(&query.to_lowercase())
-                            })
-                            .collect()
-                    }
-                })
-                .await;
-
-            this.update(&mut cx, |this, cx| {
-                this.delegate.filtered_commands = filtered_commands;
-                this.delegate.set_selected_index(0, cx);
-                cx.notify();
-            })
-            .ok();
-        })
-    }
-
-    fn separators_after_indices(&self) -> Vec<usize> {
-        let mut ret = vec![];
-        let mut previous_is_advert = false;
-
-        for (index, command) in self.filtered_commands.iter().enumerate() {
-            if previous_is_advert {
-                if let SlashCommandEntry::Info(_) = command {
-                    previous_is_advert = false;
-                    debug_assert_ne!(
-                        index, 0,
-                        "index cannot be zero, as we can never have a separator at 0th position"
-                    );
-                    ret.push(index - 1);
-                }
-            } else {
-                if let SlashCommandEntry::Advert { .. } = command {
-                    previous_is_advert = true;
-                    if index != 0 {
-                        ret.push(index - 1);
-                    }
-                }
-            }
-        }
-        ret
-    }
-    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
-        if let Some(command) = self.filtered_commands.get(self.selected_index) {
-            if let SlashCommandEntry::Info(info) = command {
-                self.active_context_editor
-                    .update(cx, |context_editor, cx| {
-                        context_editor.insert_command(&info.name, cx)
-                    })
-                    .ok();
-            } else if let SlashCommandEntry::Advert { on_confirm, .. } = command {
-                on_confirm(cx);
-            }
-            cx.emit(DismissEvent);
-        }
-    }
-
-    fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}
-
-    fn editor_position(&self) -> PickerEditorPosition {
-        PickerEditorPosition::End
-    }
-
-    fn render_match(
-        &self,
-        ix: usize,
-        selected: bool,
-        cx: &mut ViewContext<Picker<Self>>,
-    ) -> Option<Self::ListItem> {
-        let command_info = self.filtered_commands.get(ix)?;
-
-        match command_info {
-            SlashCommandEntry::Info(info) => Some(
-                ListItem::new(ix)
-                    .inset(true)
-                    .spacing(ListItemSpacing::Sparse)
-                    .selected(selected)
-                    .child(
-                        h_flex()
-                            .group(format!("command-entry-label-{ix}"))
-                            .w_full()
-                            .min_w(px(220.))
-                            .child(
-                                v_flex()
-                                    .child(
-                                        h_flex()
-                                            .child(div().font_buffer(cx).child({
-                                                let mut label = format!("/{}", info.name);
-                                                if let Some(args) =
-                                                    info.args.as_ref().filter(|_| selected)
-                                                {
-                                                    label.push_str(&args);
-                                                }
-                                                Label::new(label).size(LabelSize::Small)
-                                            }))
-                                            .children(info.args.clone().filter(|_| !selected).map(
-                                                |args| {
-                                                    div()
-                                                        .font_buffer(cx)
-                                                        .child(
-                                                            Label::new(args).size(LabelSize::Small),
-                                                        )
-                                                        .visible_on_hover(format!(
-                                                            "command-entry-label-{ix}"
-                                                        ))
-                                                },
-                                            )),
-                                    )
-                                    .child(
-                                        Label::new(info.description.clone())
-                                            .size(LabelSize::Small)
-                                            .color(Color::Muted),
-                                    ),
-                            ),
-                    ),
-            ),
-            SlashCommandEntry::Advert { renderer, .. } => Some(
-                ListItem::new(ix)
-                    .inset(true)
-                    .spacing(ListItemSpacing::Sparse)
-                    .selected(selected)
-                    .child(renderer(cx)),
-            ),
-        }
-    }
-}
-
-impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
-    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
-        let all_models = self
-            .registry
-            .featured_command_names()
-            .into_iter()
-            .filter_map(|command_name| {
-                let command = self.registry.command(&command_name)?;
-                let menu_text = SharedString::from(Arc::from(command.menu_text()));
-                let label = command.label(cx);
-                let args = label.filter_range.end.ne(&label.text.len()).then(|| {
-                    SharedString::from(
-                        label.text[label.filter_range.end..label.text.len()].to_owned(),
-                    )
-                });
-                Some(SlashCommandEntry::Info(SlashCommandInfo {
-                    name: command_name.into(),
-                    description: menu_text,
-                    args,
-                }))
-            })
-            .chain([SlashCommandEntry::Advert {
-                name: "create-your-command".into(),
-                renderer: |cx| {
-                    v_flex()
-                        .child(
-                            h_flex()
-                                .font_buffer(cx)
-                                .items_center()
-                                .gap_1()
-                                .child(div().font_buffer(cx).child(
-                                    Label::new("create-your-command").size(LabelSize::Small),
-                                ))
-                                .child(Icon::new(IconName::ArrowUpRight).size(IconSize::XSmall)),
-                        )
-                        .child(
-                            Label::new("Learn how to create a custom command")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                        )
-                        .into_any_element()
-                },
-                on_confirm: |cx| cx.open_url("https://zed.dev/docs/extensions/slash-commands"),
-            }])
-            .collect::<Vec<_>>();
-
-        let delegate = SlashCommandDelegate {
-            all_commands: all_models.clone(),
-            active_context_editor: self.active_context_editor.clone(),
-            filtered_commands: all_models,
-            selected_index: 0,
-        };
-
-        let picker_view = cx.new_view(|cx| {
-            let picker = Picker::uniform_list(delegate, cx).max_height(Some(rems(20.).into()));
-            picker
-        });
-
-        let handle = self
-            .active_context_editor
-            .update(cx, |this, _| this.slash_menu_handle.clone())
-            .ok();
-        PopoverMenu::new("model-switcher")
-            .menu(move |_cx| Some(picker_view.clone()))
-            .trigger(self.trigger)
-            .attach(gpui::AnchorCorner::TopLeft)
-            .anchor(gpui::AnchorCorner::BottomLeft)
-            .offset(gpui::Point {
-                x: px(0.0),
-                y: px(-16.0),
-            })
-            .when_some(handle, |this, handle| this.with_handle(handle))
-    }
-}

crates/assistant/src/slash_command_settings.rs

@@ -1,44 +0,0 @@
-use anyhow::Result;
-use gpui::AppContext;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources};
-
-/// Settings for slash commands.
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
-pub struct SlashCommandSettings {
-    /// Settings for the `/docs` slash command.
-    #[serde(default)]
-    pub docs: DocsCommandSettings,
-    /// Settings for the `/project` slash command.
-    #[serde(default)]
-    pub project: ProjectCommandSettings,
-}
-
-/// Settings for the `/docs` slash command.
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
-pub struct DocsCommandSettings {
-    /// Whether `/docs` is enabled.
-    #[serde(default)]
-    pub enabled: bool,
-}
-
-/// Settings for the `/project` slash command.
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
-pub struct ProjectCommandSettings {
-    /// Whether `/project` is enabled.
-    #[serde(default)]
-    pub enabled: bool,
-}
-
-impl Settings for SlashCommandSettings {
-    const KEY: Option<&'static str> = Some("slash_commands");
-
-    type FileContent = Self;
-
-    fn load(sources: SettingsSources<Self::FileContent>, _cx: &mut AppContext) -> Result<Self> {
-        SettingsSources::<Self::FileContent>::json_merge_with(
-            [sources.default].into_iter().chain(sources.user),
-        )
-    }
-}

crates/assistant/src/terminal_inline_assistant.rs

@@ -276,8 +276,7 @@ impl TerminalInlineAssistant {
 
         messages.push(LanguageModelRequestMessage {
             role: Role::User,
-            content: vec![prompt.into()],
-            cache: false,
+            content: prompt,
         });
 
         Ok(LanguageModelRequest {

crates/assistant/src/using-the-assistant.md

@@ -0,0 +1,25 @@
+### Using the Assistant
+
+Once you have configured a provider, you can interact with the provider's language models in a context editor.
+
+To create a new context editor, use the menu in the top right of the assistant panel and the `New Context` option.
+
+In the context editor, select a model from one of the configured providers, type a message in the `You` block, and submit with `cmd-enter` (or `ctrl-enter` on Linux).
+
+### Inline assistant
+
+When you're in a normal editor, you can use `ctrl-enter` to open the inline assistant.
+
+The inline assistant allows you to send the current selection (or the current line) to a language model and modify the selection with the language model's response.
+
+### Adding Prompts
+
+You can customize the default prompts that are used in new context editor, by opening the `Prompt Library`.
+
+Open the `Prompt Library` using either the menu in the top right of the assistant panel and choosing the `Prompt Library` option, or by using the `assistant: deploy prompt library` command when the assistant panel is focused.
+
+### Viewing past contexts
+
+You view all previous contexts by opening up the `History` tab in the assistant panel.
+
+Open the `History` using the menu in the top right of the assistant panel and choosing the `History`.

crates/assistant/src/workflow.rs

@@ -1,803 +0,0 @@
-mod step_view;
-
-use crate::{
-    prompts::StepResolutionContext, AssistantPanel, Context, InlineAssistId, InlineAssistant,
-};
-use anyhow::{anyhow, Error, Result};
-use collections::HashMap;
-use editor::Editor;
-use futures::future;
-use gpui::{
-    Model, ModelContext, Task, UpdateGlobal as _, View, WeakModel, WeakView, WindowContext,
-};
-use language::{Anchor, Buffer, BufferSnapshot, SymbolPath};
-use language_model::{LanguageModelRegistry, LanguageModelRequestMessage, Role};
-use project::Project;
-use rope::Point;
-use serde::{Deserialize, Serialize};
-use smol::stream::StreamExt;
-use std::{cmp, fmt::Write, ops::Range, sync::Arc};
-use text::{AnchorRangeExt as _, OffsetRangeExt as _};
-use util::ResultExt as _;
-use workspace::Workspace;
-
-pub use step_view::WorkflowStepView;
-
-const IMPORTS_SYMBOL: &str = "#imports";
-
-pub struct WorkflowStep {
-    context: WeakModel<Context>,
-    context_buffer_range: Range<Anchor>,
-    tool_output: String,
-    resolve_task: Option<Task<()>>,
-    pub resolution: Option<Result<WorkflowStepResolution, Arc<Error>>>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub 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 {
-        symbol_path: SymbolPath,
-        range: Range<language::Anchor>,
-        description: String,
-    },
-    CreateFile {
-        description: String,
-    },
-    InsertSiblingBefore {
-        symbol_path: SymbolPath,
-        position: language::Anchor,
-        description: String,
-    },
-    InsertSiblingAfter {
-        symbol_path: SymbolPath,
-        position: language::Anchor,
-        description: String,
-    },
-    PrependChild {
-        symbol_path: Option<SymbolPath>,
-        position: language::Anchor,
-        description: String,
-    },
-    AppendChild {
-        symbol_path: Option<SymbolPath>,
-        position: language::Anchor,
-        description: String,
-    },
-    Delete {
-        symbol_path: SymbolPath,
-        range: Range<language::Anchor>,
-    },
-}
-
-impl WorkflowStep {
-    pub fn new(range: Range<Anchor>, context: WeakModel<Context>) -> Self {
-        Self {
-            context_buffer_range: range,
-            tool_output: String::new(),
-            context,
-            resolution: None,
-            resolve_task: None,
-        }
-    }
-
-    pub fn resolve(&mut self, cx: &mut ModelContext<WorkflowStep>) -> Option<()> {
-        let range = self.context_buffer_range.clone();
-        let context = self.context.upgrade()?;
-        let context = context.read(cx);
-        let project = context.project()?;
-        let prompt_builder = context.prompt_builder();
-        let mut request = context.to_completion_request(cx);
-        let model = LanguageModelRegistry::read_global(cx).active_model();
-        let context_buffer = context.buffer();
-        let step_text = context_buffer
-            .read(cx)
-            .text_for_range(range.clone())
-            .collect::<String>();
-
-        let mut workflow_context = String::new();
-        for message in context.messages(cx) {
-            write!(&mut workflow_context, "<message role={}>", message.role).unwrap();
-            for chunk in context_buffer.read(cx).text_for_range(message.offset_range) {
-                write!(&mut workflow_context, "{chunk}").unwrap();
-            }
-            write!(&mut workflow_context, "</message>").unwrap();
-        }
-
-        self.resolve_task = Some(cx.spawn(|this, mut cx| async move {
-            let result = async {
-                let Some(model) = model else {
-                    return Err(anyhow!("no model selected"));
-                };
-
-                this.update(&mut cx, |this, cx| {
-                    this.tool_output.clear();
-                    this.resolution = None;
-                    this.result_updated(cx);
-                    cx.notify();
-                })?;
-
-                let resolution_context = StepResolutionContext {
-                    workflow_context,
-                    step_to_resolve: step_text.clone(),
-                };
-                let mut prompt =
-                    prompt_builder.generate_step_resolution_prompt(&resolution_context)?;
-                prompt.push_str(&step_text);
-                request.messages.push(LanguageModelRequestMessage {
-                    role: Role::User,
-                    content: vec![prompt.into()],
-                    cache: false,
-                });
-
-                // Invoke the model to get its edit suggestions for this workflow step.
-                let mut stream = model
-                    .use_tool_stream::<tool::WorkflowStepResolutionTool>(request, &cx)
-                    .await?;
-                while let Some(chunk) = stream.next().await {
-                    let chunk = chunk?;
-                    this.update(&mut cx, |this, cx| {
-                        this.tool_output.push_str(&chunk);
-                        cx.notify();
-                    })?;
-                }
-
-                let resolution = this.update(&mut cx, |this, _| {
-                    serde_json::from_str::<tool::WorkflowStepResolutionTool>(&this.tool_output)
-                })??;
-
-                this.update(&mut cx, |this, cx| {
-                    this.tool_output = serde_json::to_string_pretty(&resolution).unwrap();
-                    cx.notify();
-                })?;
-
-                // Translate the parsed suggestions to our internal types, which anchor the suggestions to locations in the code.
-                let suggestion_tasks: Vec<_> = resolution
-                    .suggestions
-                    .iter()
-                    .map(|suggestion| suggestion.resolve(project.clone(), cx.clone()))
-                    .collect();
-
-                // Expand the context ranges of each suggestion and group suggestions with overlapping context ranges.
-                let suggestions = future::join_all(suggestion_tasks)
-                    .await
-                    .into_iter()
-                    .filter_map(|task| task.log_err())
-                    .collect::<Vec<_>>();
-
-                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(&mut 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 {
-                            // Create the first group
-                            suggestion_groups.push(WorkflowSuggestionGroup {
-                                context_range,
-                                suggestions: vec![suggestion],
-                            });
-                        }
-                    }
-
-                    suggestion_groups_by_buffer.insert(buffer, suggestion_groups);
-                }
-
-                Ok((resolution.step_title, suggestion_groups_by_buffer))
-            };
-
-            let result = result.await;
-            this.update(&mut cx, |this, cx| {
-                this.resolution = Some(match result {
-                    Ok((title, suggestion_groups)) => Ok(WorkflowStepResolution {
-                        title,
-                        suggestion_groups,
-                    }),
-                    Err(error) => Err(Arc::new(error)),
-                });
-                this.context
-                    .update(cx, |context, cx| context.workflow_step_updated(range, cx))
-                    .ok();
-                cx.notify();
-            })
-            .ok();
-        }));
-        None
-    }
-
-    fn result_updated(&mut self, cx: &mut ModelContext<Self>) {
-        self.context
-            .update(cx, |context, cx| {
-                context.workflow_step_updated(self.context_buffer_range.clone(), cx)
-            })
-            .ok();
-    }
-}
-
-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::InsertSiblingBefore { position, .. }
-            | Self::InsertSiblingAfter { position, .. }
-            | Self::PrependChild { position, .. }
-            | Self::AppendChild { position, .. } => *position..*position,
-            Self::Delete { range, .. } => range.clone(),
-        }
-    }
-
-    pub fn description(&self) -> Option<&str> {
-        match self {
-            Self::Update { description, .. }
-            | Self::CreateFile { description }
-            | Self::InsertSiblingBefore { description, .. }
-            | Self::InsertSiblingAfter { description, .. }
-            | Self::PrependChild { description, .. }
-            | Self::AppendChild { description, .. } => Some(description),
-            Self::Delete { .. } => None,
-        }
-    }
-
-    fn description_mut(&mut self) -> Option<&mut String> {
-        match self {
-            Self::Update { description, .. }
-            | Self::CreateFile { description }
-            | Self::InsertSiblingBefore { description, .. }
-            | Self::InsertSiblingAfter { description, .. }
-            | Self::PrependChild { description, .. }
-            | Self::AppendChild { description, .. } => Some(description),
-            Self::Delete { .. } => None,
-        }
-    }
-
-    fn symbol_path(&self) -> Option<&SymbolPath> {
-        match self {
-            Self::Update { symbol_path, .. } => Some(symbol_path),
-            Self::InsertSiblingBefore { symbol_path, .. } => Some(symbol_path),
-            Self::InsertSiblingAfter { symbol_path, .. } => Some(symbol_path),
-            Self::PrependChild { symbol_path, .. } => symbol_path.as_ref(),
-            Self::AppendChild { symbol_path, .. } => symbol_path.as_ref(),
-            Self::Delete { symbol_path, .. } => Some(symbol_path),
-            Self::CreateFile { .. } => None,
-        }
-    }
-
-    fn kind(&self) -> &str {
-        match self {
-            Self::Update { .. } => "Update",
-            Self::CreateFile { .. } => "CreateFile",
-            Self::InsertSiblingBefore { .. } => "InsertSiblingBefore",
-            Self::InsertSiblingAfter { .. } => "InsertSiblingAfter",
-            Self::PrependChild { .. } => "PrependChild",
-            Self::AppendChild { .. } => "AppendChild",
-            Self::Delete { .. } => "Delete",
-        }
-    }
-
-    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::InsertSiblingBefore {
-                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::InsertSiblingAfter {
-                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::PrependChild {
-                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, false, 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::AppendChild {
-                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, false, 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,
-                Some(workspace.clone()),
-                Some(assistant_panel),
-                cx,
-            ))
-        })
-    }
-}
-
-pub mod tool {
-    use super::*;
-    use anyhow::Context as _;
-    use gpui::AsyncAppContext;
-    use language::{Outline, OutlineItem, ParseStatus};
-    use language_model::LanguageModelTool;
-    use project::ProjectPath;
-    use schemars::JsonSchema;
-    use std::path::Path;
-
-    #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-    pub struct WorkflowStepResolutionTool {
-        /// An extremely short title for the edit step represented by these operations.
-        pub step_title: String,
-        /// A sequence of operations to apply to the codebase.
-        /// When multiple operations are required for a step, be sure to include multiple operations in this list.
-        pub suggestions: Vec<WorkflowSuggestionTool>,
-    }
-
-    impl LanguageModelTool for WorkflowStepResolutionTool {
-        fn name() -> String {
-            "edit".into()
-        }
-
-        fn description() -> String {
-            "suggest edits to one or more locations in the codebase".into()
-        }
-    }
-
-    /// A description of an operation to apply to one location in the codebase.
-    ///
-    /// This object represents a single edit operation that can be performed on a specific file
-    /// in the codebase. It encapsulates both the location (file path) and the nature of the
-    /// edit to be made.
-    ///
-    /// # Fields
-    ///
-    /// * `path`: A string representing the file path where the edit operation should be applied.
-    ///           This path is relative to the root of the project or repository.
-    ///
-    /// * `kind`: An enum representing the specific type of edit operation to be performed.
-    ///
-    /// # Usage
-    ///
-    /// `EditOperation` is used within a code editor to represent and apply
-    /// programmatic changes to source code. It provides a structured way to describe
-    /// edits for features like refactoring tools or AI-assisted coding suggestions.
-    #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-    pub struct WorkflowSuggestionTool {
-        /// The path to the file containing the relevant operation
-        pub path: String,
-        #[serde(flatten)]
-        pub kind: WorkflowSuggestionToolKind,
-    }
-
-    impl WorkflowSuggestionTool {
-        pub(super) 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 mut parse_status = buffer.read_with(&cx, |buffer, _cx| buffer.parse_status())?;
-            while *parse_status.borrow() != ParseStatus::Idle {
-                parse_status.changed().await?;
-            }
-
-            let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
-            let outline = snapshot.outline(None).context("no outline for buffer")?;
-
-            let suggestion = match kind {
-                WorkflowSuggestionToolKind::Update {
-                    symbol,
-                    description,
-                } => {
-                    let (symbol_path, symbol) = Self::resolve_symbol(&snapshot, &outline, &symbol)?;
-                    let start = symbol
-                        .annotation_range
-                        .map_or(symbol.range.start, |range| range.start);
-                    let start = Point::new(start.row, 0);
-                    let end = Point::new(
-                        symbol.range.end.row,
-                        snapshot.line_len(symbol.range.end.row),
-                    );
-                    let range = snapshot.anchor_before(start)..snapshot.anchor_after(end);
-                    WorkflowSuggestion::Update {
-                        range,
-                        description,
-                        symbol_path,
-                    }
-                }
-                WorkflowSuggestionToolKind::Create { description } => {
-                    WorkflowSuggestion::CreateFile { description }
-                }
-                WorkflowSuggestionToolKind::InsertSiblingBefore {
-                    symbol,
-                    description,
-                } => {
-                    let (symbol_path, symbol) = Self::resolve_symbol(&snapshot, &outline, &symbol)?;
-                    let position = snapshot.anchor_before(
-                        symbol
-                            .annotation_range
-                            .map_or(symbol.range.start, |annotation_range| {
-                                annotation_range.start
-                            }),
-                    );
-                    WorkflowSuggestion::InsertSiblingBefore {
-                        position,
-                        description,
-                        symbol_path,
-                    }
-                }
-                WorkflowSuggestionToolKind::InsertSiblingAfter {
-                    symbol,
-                    description,
-                } => {
-                    let (symbol_path, symbol) = Self::resolve_symbol(&snapshot, &outline, &symbol)?;
-                    let position = snapshot.anchor_after(symbol.range.end);
-                    WorkflowSuggestion::InsertSiblingAfter {
-                        position,
-                        description,
-                        symbol_path,
-                    }
-                }
-                WorkflowSuggestionToolKind::PrependChild {
-                    symbol,
-                    description,
-                } => {
-                    if let Some(symbol) = symbol {
-                        let (symbol_path, symbol) =
-                            Self::resolve_symbol(&snapshot, &outline, &symbol)?;
-
-                        let position = snapshot.anchor_after(
-                            symbol
-                                .body_range
-                                .map_or(symbol.range.start, |body_range| body_range.start),
-                        );
-                        WorkflowSuggestion::PrependChild {
-                            position,
-                            description,
-                            symbol_path: Some(symbol_path),
-                        }
-                    } else {
-                        WorkflowSuggestion::PrependChild {
-                            position: language::Anchor::MIN,
-                            description,
-                            symbol_path: None,
-                        }
-                    }
-                }
-                WorkflowSuggestionToolKind::AppendChild {
-                    symbol,
-                    description,
-                } => {
-                    if let Some(symbol) = symbol {
-                        let (symbol_path, symbol) =
-                            Self::resolve_symbol(&snapshot, &outline, &symbol)?;
-
-                        let position = snapshot.anchor_before(
-                            symbol
-                                .body_range
-                                .map_or(symbol.range.end, |body_range| body_range.end),
-                        );
-                        WorkflowSuggestion::AppendChild {
-                            position,
-                            description,
-                            symbol_path: Some(symbol_path),
-                        }
-                    } else {
-                        WorkflowSuggestion::PrependChild {
-                            position: language::Anchor::MAX,
-                            description,
-                            symbol_path: None,
-                        }
-                    }
-                }
-                WorkflowSuggestionToolKind::Delete { symbol } => {
-                    let (symbol_path, symbol) = Self::resolve_symbol(&snapshot, &outline, &symbol)?;
-                    let start = symbol
-                        .annotation_range
-                        .map_or(symbol.range.start, |range| range.start);
-                    let start = Point::new(start.row, 0);
-                    let end = Point::new(
-                        symbol.range.end.row,
-                        snapshot.line_len(symbol.range.end.row),
-                    );
-                    let range = snapshot.anchor_before(start)..snapshot.anchor_after(end);
-                    WorkflowSuggestion::Delete { range, symbol_path }
-                }
-            };
-
-            Ok((buffer, suggestion))
-        }
-
-        fn resolve_symbol(
-            snapshot: &BufferSnapshot,
-            outline: &Outline<Anchor>,
-            symbol: &str,
-        ) -> Result<(SymbolPath, OutlineItem<Point>)> {
-            if symbol == IMPORTS_SYMBOL {
-                let target_row = find_first_non_comment_line(snapshot);
-                Ok((
-                    SymbolPath(IMPORTS_SYMBOL.to_string()),
-                    OutlineItem {
-                        range: Point::new(target_row, 0)..Point::new(target_row + 1, 0),
-                        ..Default::default()
-                    },
-                ))
-            } else {
-                let (symbol_path, symbol) = outline
-                    .find_most_similar(symbol)
-                    .with_context(|| format!("symbol not found: {symbol}"))?;
-                Ok((symbol_path, symbol.to_point(snapshot)))
-            }
-        }
-    }
-
-    fn find_first_non_comment_line(snapshot: &BufferSnapshot) -> u32 {
-        let Some(language) = snapshot.language() else {
-            return 0;
-        };
-
-        let scope = language.default_scope();
-        let comment_prefixes = scope.line_comment_prefixes();
-
-        let mut chunks = snapshot.as_rope().chunks();
-        let mut target_row = 0;
-        loop {
-            let starts_with_comment = chunks
-                .peek()
-                .map(|chunk| {
-                    comment_prefixes
-                        .iter()
-                        .any(|s| chunk.starts_with(s.as_ref().trim_end()))
-                })
-                .unwrap_or(false);
-
-            if !starts_with_comment {
-                break;
-            }
-
-            target_row += 1;
-            if !chunks.next_line() {
-                break;
-            }
-        }
-        target_row
-    }
-
-    #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-    #[serde(tag = "kind")]
-    pub enum WorkflowSuggestionToolKind {
-        /// Rewrites the specified symbol entirely based on the given description.
-        /// This operation completely replaces the existing symbol with new content.
-        Update {
-            /// A fully-qualified reference to the symbol, e.g. `mod foo impl Bar pub fn baz` instead of just `fn baz`.
-            /// The path should uniquely identify the symbol within the containing file.
-            symbol: 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 a new symbol based on the given description before the specified symbol.
-        /// This operation adds new content immediately preceding an existing symbol.
-        InsertSiblingBefore {
-            /// A fully-qualified reference to the symbol, e.g. `mod foo impl Bar pub fn baz` instead of just `fn baz`.
-            /// The new content will be inserted immediately before this symbol.
-            symbol: String,
-            /// A brief description of the new symbol to be inserted.
-            description: String,
-        },
-        /// Inserts a new symbol based on the given description after the specified symbol.
-        /// This operation adds new content immediately following an existing symbol.
-        InsertSiblingAfter {
-            /// A fully-qualified reference to the symbol, e.g. `mod foo impl Bar pub fn baz` instead of just `fn baz`.
-            /// The new content will be inserted immediately after this symbol.
-            symbol: String,
-            /// A brief description of the new symbol to be inserted.
-            description: String,
-        },
-        /// Inserts a new symbol as a child of the specified symbol at the start.
-        /// This operation adds new content as the first child of an existing symbol (or file if no symbol is provided).
-        PrependChild {
-            /// An optional fully-qualified reference to the symbol after the code you want to insert, e.g. `mod foo impl Bar pub fn baz` instead of just `fn baz`.
-            /// If provided, the new content will be inserted as the first child of this symbol.
-            /// If not provided, the new content will be inserted at the top of the file.
-            symbol: Option<String>,
-            /// A brief description of the new symbol to be inserted.
-            description: String,
-        },
-        /// Inserts a new symbol as a child of the specified symbol at the end.
-        /// This operation adds new content as the last child of an existing symbol (or file if no symbol is provided).
-        AppendChild {
-            /// An optional fully-qualified reference to the symbol before the code you want to insert, e.g. `mod foo impl Bar pub fn baz` instead of just `fn baz`.
-            /// If provided, the new content will be inserted as the last child of this symbol.
-            /// If not provided, the new content will be applied at the bottom of the file.
-            symbol: Option<String>,
-            /// A brief description of the new symbol to be inserted.
-            description: String,
-        },
-        /// Deletes the specified symbol from the containing file.
-        Delete {
-            /// An fully-qualified reference to the symbol to be deleted, e.g. `mod foo impl Bar pub fn baz` instead of just `fn baz`.
-            symbol: String,
-        },
-    }
-}

crates/assistant/src/workflow/step_view.rs

@@ -1,315 +0,0 @@
-use super::WorkflowStep;
-use crate::{Assist, Context};
-use editor::{
-    display_map::{BlockDisposition, BlockProperties, BlockStyle},
-    Editor, EditorEvent, ExcerptRange, MultiBuffer,
-};
-use gpui::{
-    div, AnyElement, AppContext, Context as _, Empty, EventEmitter, FocusableView, IntoElement,
-    Model, ParentElement as _, Render, SharedString, Styled as _, View, ViewContext,
-    VisualContext as _, WeakModel, WindowContext,
-};
-use language::{language_settings::SoftWrap, Anchor, Buffer, LanguageRegistry};
-use std::{ops::DerefMut, sync::Arc};
-use text::OffsetRangeExt;
-use theme::ActiveTheme as _;
-use ui::{
-    h_flex, v_flex, ButtonCommon as _, ButtonLike, ButtonStyle, Color, Icon, IconName,
-    InteractiveElement as _, Label, LabelCommon as _,
-};
-use workspace::{
-    item::{self, Item},
-    pane,
-    searchable::SearchableItemHandle,
-};
-
-pub struct WorkflowStepView {
-    step: WeakModel<WorkflowStep>,
-    tool_output_buffer: Model<Buffer>,
-    editor: View<Editor>,
-}
-
-impl WorkflowStepView {
-    pub fn new(
-        context: Model<Context>,
-        step: Model<WorkflowStep>,
-        language_registry: Arc<LanguageRegistry>,
-        cx: &mut ViewContext<Self>,
-    ) -> Self {
-        let tool_output_buffer =
-            cx.new_model(|cx| Buffer::local(step.read(cx).tool_output.clone(), cx));
-        let buffer = cx.new_model(|cx| {
-            let mut buffer = MultiBuffer::without_headers(0, language::Capability::ReadWrite);
-            buffer.push_excerpts(
-                context.read(cx).buffer().clone(),
-                [ExcerptRange {
-                    context: step.read(cx).context_buffer_range.clone(),
-                    primary: None,
-                }],
-                cx,
-            );
-            buffer.push_excerpts(
-                tool_output_buffer.clone(),
-                [ExcerptRange {
-                    context: Anchor::MIN..Anchor::MAX,
-                    primary: None,
-                }],
-                cx,
-            );
-            buffer
-        });
-
-        let buffer_snapshot = buffer.read(cx).snapshot(cx);
-        let output_excerpt = buffer_snapshot.excerpts().skip(1).next().unwrap().0;
-        let input_start_anchor = multi_buffer::Anchor::min();
-        let output_start_anchor = buffer_snapshot
-            .anchor_in_excerpt(output_excerpt, Anchor::MIN)
-            .unwrap();
-        let output_end_anchor = multi_buffer::Anchor::max();
-
-        let handle = cx.view().downgrade();
-        let editor = cx.new_view(|cx| {
-            let mut editor = Editor::for_multibuffer(buffer.clone(), None, false, cx);
-            editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
-            editor.set_show_line_numbers(false, cx);
-            editor.set_show_git_diff_gutter(false, cx);
-            editor.set_show_code_actions(false, cx);
-            editor.set_show_runnables(false, cx);
-            editor.set_show_wrap_guides(false, cx);
-            editor.set_show_indent_guides(false, cx);
-            editor.set_read_only(true);
-            editor.set_show_inline_completions(false);
-            editor.insert_blocks(
-                [
-                    BlockProperties {
-                        position: input_start_anchor,
-                        height: 1,
-                        style: BlockStyle::Fixed,
-                        render: Box::new(|cx| section_header("Step Input", cx)),
-                        disposition: BlockDisposition::Above,
-                        priority: 0,
-                    },
-                    BlockProperties {
-                        position: output_start_anchor,
-                        height: 1,
-                        style: BlockStyle::Fixed,
-                        render: Box::new(|cx| section_header("Tool Output", cx)),
-                        disposition: BlockDisposition::Above,
-                        priority: 0,
-                    },
-                    BlockProperties {
-                        position: output_end_anchor,
-                        height: 1,
-                        style: BlockStyle::Fixed,
-                        render: Box::new(move |cx| {
-                            if let Some(result) = handle.upgrade().and_then(|this| {
-                                this.update(cx.deref_mut(), |this, cx| this.render_result(cx))
-                            }) {
-                                v_flex()
-                                    .child(section_header("Output", cx))
-                                    .child(
-                                        div().pl(cx.gutter_dimensions.full_width()).child(result),
-                                    )
-                                    .into_any_element()
-                            } else {
-                                Empty.into_any_element()
-                            }
-                        }),
-                        disposition: BlockDisposition::Below,
-                        priority: 0,
-                    },
-                ],
-                None,
-                cx,
-            );
-            editor
-        });
-
-        cx.observe(&step, Self::step_updated).detach();
-        cx.observe_release(&step, Self::step_released).detach();
-
-        cx.spawn(|this, mut cx| async move {
-            if let Ok(language) = language_registry.language_for_name("JSON").await {
-                this.update(&mut cx, |this, cx| {
-                    this.tool_output_buffer.update(cx, |buffer, cx| {
-                        buffer.set_language(Some(language), cx);
-                    });
-                })
-                .ok();
-            }
-        })
-        .detach();
-
-        Self {
-            tool_output_buffer,
-            step: step.downgrade(),
-            editor,
-        }
-    }
-
-    pub fn step(&self) -> &WeakModel<WorkflowStep> {
-        &self.step
-    }
-
-    fn render_result(&mut self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
-        let step = self.step.upgrade()?;
-        let result = step.read(cx).resolution.as_ref()?;
-        match result {
-            Ok(result) => {
-                Some(
-                    v_flex()
-                        .child(result.title.clone())
-                        .children(result.suggestion_groups.iter().filter_map(
-                            |(buffer, suggestion_groups)| {
-                                let buffer = buffer.read(cx);
-                                let path = buffer.file().map(|f| f.path());
-                                let snapshot = buffer.snapshot();
-                                v_flex()
-                                    .mb_2()
-                                    .border_b_1()
-                                    .children(path.map(|path| format!("path: {}", path.display())))
-                                    .children(suggestion_groups.iter().map(|group| {
-                                        v_flex().pt_2().pl_2().children(
-                                            group.suggestions.iter().map(|suggestion| {
-                                                let range = suggestion.range().to_point(&snapshot);
-                                                v_flex()
-                                                    .children(
-                                                        suggestion.description().map(|desc| {
-                                                            format!("description: {desc}")
-                                                        }),
-                                                    )
-                                                    .child(format!("kind: {}", suggestion.kind()))
-                                                    .children(suggestion.symbol_path().map(
-                                                        |path| format!("symbol path: {}", path.0),
-                                                    ))
-                                                    .child(format!(
-                                                        "lines: {} - {}",
-                                                        range.start.row + 1,
-                                                        range.end.row + 1
-                                                    ))
-                                            }),
-                                        )
-                                    }))
-                                    .into()
-                            },
-                        ))
-                        .into_any_element(),
-                )
-            }
-            Err(error) => Some(format!("{:?}", error).into_any_element()),
-        }
-    }
-
-    fn step_updated(&mut self, step: Model<WorkflowStep>, cx: &mut ViewContext<Self>) {
-        self.tool_output_buffer.update(cx, |buffer, cx| {
-            let text = step.read(cx).tool_output.clone();
-            buffer.set_text(text, cx);
-        });
-        cx.notify();
-    }
-
-    fn step_released(&mut self, _: &mut WorkflowStep, cx: &mut ViewContext<Self>) {
-        cx.emit(EditorEvent::Closed);
-    }
-
-    fn resolve(&mut self, _: &Assist, cx: &mut ViewContext<Self>) {
-        self.step
-            .update(cx, |step, cx| {
-                step.resolve(cx);
-            })
-            .ok();
-    }
-}
-
-fn section_header(
-    name: &'static str,
-    cx: &mut editor::display_map::BlockContext,
-) -> gpui::AnyElement {
-    h_flex()
-        .pl(cx.gutter_dimensions.full_width())
-        .h_11()
-        .w_full()
-        .relative()
-        .gap_1()
-        .child(
-            ButtonLike::new("role")
-                .style(ButtonStyle::Filled)
-                .child(Label::new(name).color(Color::Default)),
-        )
-        .into_any_element()
-}
-
-impl Render for WorkflowStepView {
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        div()
-            .key_context("ContextEditor")
-            .on_action(cx.listener(Self::resolve))
-            .flex_grow()
-            .bg(cx.theme().colors().editor_background)
-            .child(self.editor.clone())
-    }
-}
-
-impl EventEmitter<EditorEvent> for WorkflowStepView {}
-
-impl FocusableView for WorkflowStepView {
-    fn focus_handle(&self, cx: &gpui::AppContext) -> gpui::FocusHandle {
-        self.editor.read(cx).focus_handle(cx)
-    }
-}
-
-impl Item for WorkflowStepView {
-    type Event = EditorEvent;
-
-    fn tab_content_text(&self, cx: &WindowContext) -> Option<SharedString> {
-        let step = self.step.upgrade()?.read(cx);
-        let context = step.context.upgrade()?.read(cx);
-        let buffer = context.buffer().read(cx);
-        let index = context
-            .workflow_step_index_for_range(&step.context_buffer_range, buffer)
-            .ok()?
-            + 1;
-        Some(format!("Step {index}").into())
-    }
-
-    fn tab_icon(&self, _cx: &WindowContext) -> Option<ui::Icon> {
-        Some(Icon::new(IconName::SearchCode))
-    }
-
-    fn to_item_events(event: &Self::Event, mut f: impl FnMut(item::ItemEvent)) {
-        match event {
-            EditorEvent::Edited { .. } => {
-                f(item::ItemEvent::Edit);
-            }
-            EditorEvent::TitleChanged => {
-                f(item::ItemEvent::UpdateTab);
-            }
-            EditorEvent::Closed => f(item::ItemEvent::CloseItem),
-            _ => {}
-        }
-    }
-
-    fn tab_tooltip_text(&self, _cx: &AppContext) -> Option<SharedString> {
-        None
-    }
-
-    fn as_searchable(&self, _handle: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
-        None
-    }
-
-    fn set_nav_history(&mut self, nav_history: pane::ItemNavHistory, cx: &mut ViewContext<Self>) {
-        self.editor.update(cx, |editor, cx| {
-            Item::set_nav_history(editor, nav_history, cx)
-        })
-    }
-
-    fn navigate(&mut self, data: Box<dyn std::any::Any>, cx: &mut ViewContext<Self>) -> bool {
-        self.editor
-            .update(cx, |editor, cx| Item::navigate(editor, data, cx))
-    }
-
-    fn deactivated(&mut self, cx: &mut ViewContext<Self>) {
-        self.editor
-            .update(cx, |editor, cx| Item::deactivated(editor, cx))
-    }
-}

crates/assistant_slash_command/src/assistant_slash_command.rs

@@ -15,45 +15,14 @@ pub fn init(cx: &mut AppContext) {
     SlashCommandRegistry::default_global(cx);
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AfterCompletion {
-    /// Run the command
-    Run,
-    /// Continue composing the current argument, doesn't add a space
-    Compose,
-    /// Continue the command composition, adds a space
-    Continue,
-}
-
-impl From<bool> for AfterCompletion {
-    fn from(value: bool) -> Self {
-        if value {
-            AfterCompletion::Run
-        } else {
-            AfterCompletion::Continue
-        }
-    }
-}
-
-impl AfterCompletion {
-    pub fn run(&self) -> bool {
-        match self {
-            AfterCompletion::Run => true,
-            AfterCompletion::Compose | AfterCompletion::Continue => false,
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct ArgumentCompletion {
     /// The label to display for this completion.
-    pub label: CodeLabel,
+    pub label: String,
     /// The new text that should be inserted into the command when this completion is accepted.
     pub new_text: String,
     /// Whether the command should be run when accepting this completion.
-    pub after_completion: AfterCompletion,
-    /// Whether to replace the all arguments, or whether to treat this as an independent argument.
-    pub replace_previous_arguments: bool,
+    pub run_command: bool,
 }
 
 pub trait SlashCommand: 'static + Send + Sync {
@@ -65,18 +34,15 @@ pub trait SlashCommand: 'static + Send + Sync {
     fn menu_text(&self) -> String;
     fn complete_argument(
         self: Arc<Self>,
-        arguments: &[String],
+        query: String,
         cancel: Arc<AtomicBool>,
         workspace: Option<WeakView<Workspace>>,
-        cx: &mut WindowContext,
+        cx: &mut AppContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>>;
     fn requires_argument(&self) -> bool;
-    fn accepts_arguments(&self) -> bool {
-        self.requires_argument()
-    }
     fn run(
         self: Arc<Self>,
-        arguments: &[String],
+        argument: Option<&str>,
         workspace: WeakView<Workspace>,
         // TODO: We're just using the `LspAdapterDelegate` here because that is
         // what the extension API is already expecting.

crates/assistant_slash_command/src/slash_command_registry.rs

@@ -56,18 +56,6 @@ impl SlashCommandRegistry {
         state.commands.insert(command_name, Arc::new(command));
     }
 
-    /// Unregisters the provided [`SlashCommand`].
-    pub fn unregister_command(&self, command: impl SlashCommand) {
-        self.unregister_command_by_name(command.name().as_str())
-    }
-
-    /// Unregisters the command with the given name.
-    pub fn unregister_command_by_name(&self, command_name: &str) {
-        let mut state = self.state.write();
-        state.featured_commands.remove(command_name);
-        state.commands.remove(command_name);
-    }
-
     /// Returns the names of registered [`SlashCommand`]s.
     pub fn command_names(&self) -> Vec<Arc<str>> {
         self.state.read().commands.keys().cloned().collect()

crates/client/src/test.rs

@@ -1,6 +1,5 @@
 use crate::{Client, Connection, Credentials, EstablishConnectionError, UserStore};
 use anyhow::{anyhow, Result};
-use chrono::Duration;
 use futures::{stream::BoxStream, StreamExt};
 use gpui::{BackgroundExecutor, Context, Model, TestAppContext};
 use parking_lot::Mutex;
@@ -163,11 +162,6 @@ impl FakeServer {
                 return Ok(*message.downcast().unwrap());
             }
 
-            let accepted_tos_at = chrono::Utc::now()
-                .checked_sub_signed(Duration::hours(5))
-                .expect("failed to build accepted_tos_at")
-                .timestamp() as u64;
-
             if message.is::<TypedEnvelope<GetPrivateUserInfo>>() {
                 self.respond(
                     message
@@ -178,7 +172,6 @@ impl FakeServer {
                         metrics_id: "the-metrics-id".into(),
                         staff: false,
                         flags: Default::default(),
-                        accepted_tos_at: Some(accepted_tos_at),
                     },
                 );
                 continue;

crates/client/src/user.rs

@@ -1,6 +1,5 @@
 use super::{proto, Client, Status, TypedEnvelope};
 use anyhow::{anyhow, Context, Result};
-use chrono::{DateTime, Utc};
 use collections::{hash_map::Entry, HashMap, HashSet};
 use feature_flags::FeatureFlagAppExt;
 use futures::{channel::mpsc, Future, StreamExt};
@@ -95,7 +94,6 @@ pub struct UserStore {
     update_contacts_tx: mpsc::UnboundedSender<UpdateContacts>,
     current_plan: Option<proto::Plan>,
     current_user: watch::Receiver<Option<Arc<User>>>,
-    accepted_tos_at: Option<Option<DateTime<Utc>>>,
     contacts: Vec<Arc<Contact>>,
     incoming_contact_requests: Vec<Arc<User>>,
     outgoing_contact_requests: Vec<Arc<User>>,
@@ -152,7 +150,6 @@ impl UserStore {
             by_github_login: Default::default(),
             current_user: current_user_rx,
             current_plan: None,
-            accepted_tos_at: None,
             contacts: Default::default(),
             incoming_contact_requests: Default::default(),
             participant_indices: Default::default(),
@@ -192,10 +189,9 @@ impl UserStore {
                                 } else {
                                     break;
                                 };
-                                let fetch_private_user_info =
+                                let fetch_metrics_id =
                                     client.request(proto::GetPrivateUserInfo {}).log_err();
-                                let (user, info) =
-                                    futures::join!(fetch_user, fetch_private_user_info);
+                                let (user, info) = futures::join!(fetch_user, fetch_metrics_id);
 
                                 cx.update(|cx| {
                                     if let Some(info) = info {
@@ -206,17 +202,9 @@ impl UserStore {
                                         client.telemetry.set_authenticated_user_info(
                                             Some(info.metrics_id.clone()),
                                             staff,
-                                        );
-
-                                        this.update(cx, |this, _| {
-                                            this.set_current_user_accepted_tos_at(
-                                                info.accepted_tos_at,
-                                            );
-                                        })
-                                    } else {
-                                        anyhow::Ok(())
+                                        )
                                     }
-                                })??;
+                                })?;
 
                                 current_user_tx.send(user).await.ok();
 
@@ -692,39 +680,6 @@ impl UserStore {
         self.current_user.clone()
     }
 
-    pub fn current_user_has_accepted_terms(&self) -> Option<bool> {
-        self.accepted_tos_at
-            .map(|accepted_tos_at| accepted_tos_at.is_some())
-    }
-
-    pub fn accept_terms_of_service(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
-        if self.current_user().is_none() {
-            return Task::ready(Err(anyhow!("no current user")));
-        };
-
-        let client = self.client.clone();
-        cx.spawn(move |this, mut cx| async move {
-            if let Some(client) = client.upgrade() {
-                let response = client
-                    .request(proto::AcceptTermsOfService {})
-                    .await
-                    .context("error accepting tos")?;
-
-                this.update(&mut cx, |this, _| {
-                    this.set_current_user_accepted_tos_at(Some(response.accepted_tos_at))
-                })
-            } else {
-                Err(anyhow!("client not found"))
-            }
-        })
-    }
-
-    fn set_current_user_accepted_tos_at(&mut self, accepted_tos_at: Option<u64>) {
-        self.accepted_tos_at = Some(
-            accepted_tos_at.and_then(|timestamp| DateTime::from_timestamp(timestamp as i64, 0)),
-        );
-    }
-
     fn load_users(
         &mut self,
         request: impl RequestMessage<Response = UsersResponse>,

crates/collab/Cargo.toml

@@ -58,7 +58,6 @@ serde_derive.workspace = true
 serde_json.workspace = true
 sha2.workspace = true
 sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "json", "time", "uuid", "any"] }
-strum.workspace = true
 subtle.workspace = true
 rustc-demangle.workspace = true
 telemetry_events.workspace = true

crates/collab/README.md

@@ -10,7 +10,7 @@ It contains our back-end logic for collaboration, to which we connect from the Z
 
 Before you can run the collab server locally, you'll need to set up a zed Postgres database.
 
-```sh
+```
 script/bootstrap
 ```
 
@@ -32,13 +32,13 @@ To use a different set of admin users, create `crates/collab/seed.json`.
 
 In one terminal, run Zed's collaboration server and the livekit dev server:
 
-```sh
+```
 foreman start
 ```
 
 In a second terminal, run two or more instances of Zed.
 
-```sh
+```
 script/zed-local -2
 ```
 
@@ -64,7 +64,7 @@ You can tell what is currently deployed with `./script/what-is-deployed`.
 
 To create a new migration:
 
-```sh
+```
 ./script/create-migration <name>
 ```
 

crates/collab/k8s/collab.template.yml

@@ -97,13 +97,6 @@ spec:
                 secretKeyRef:
                   name: llm-token
                   key: secret
-            - name: LLM_DATABASE_URL
-              valueFrom:
-                secretKeyRef:
-                  name: llm-database
-                  key: url
-            - name: LLM_DATABASE_MAX_CONNECTIONS
-              value: "${LLM_DATABASE_MAX_CONNECTIONS}"
             - name: ZED_CLIENT_CHECKSUM_SEED
               valueFrom:
                 secretKeyRef:
@@ -134,16 +127,6 @@ spec:
                 secretKeyRef:
                   name: anthropic
                   key: api_key
-            - name: ANTHROPIC_STAFF_API_KEY
-              valueFrom:
-                secretKeyRef:
-                  name: anthropic
-                  key: staff_api_key
-            - name: LLM_CLOSED_BETA_MODEL_NAME
-              valueFrom:
-                secretKeyRef:
-                  name: llm-closed-beta
-                  key: model_name
             - name: GOOGLE_AI_API_KEY
               valueFrom:
                 secretKeyRef:

crates/collab/k8s/environments/production.sh

@@ -3,4 +3,3 @@ RUST_LOG=info
 INVITE_LINK_PREFIX=https://zed.dev/invites/
 AUTO_JOIN_CHANNEL_ID=283
 DATABASE_MAX_CONNECTIONS=85
-LLM_DATABASE_MAX_CONNECTIONS=25

crates/collab/k8s/environments/staging.sh

@@ -2,5 +2,4 @@ ZED_ENVIRONMENT=staging
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://staging.zed.dev/invites/
 DATABASE_MAX_CONNECTIONS=5
-LLM_DATABASE_MAX_CONNECTIONS=5
 AUTO_JOIN_CHANNEL_ID=8

crates/collab/k8s/postgrest.template.yml

@@ -12,7 +12,7 @@ metadata:
 spec:
   type: LoadBalancer
   selector:
-    app: nginx
+    app: postgrest
   ports:
     - name: web
       protocol: TCP
@@ -24,99 +24,17 @@ apiVersion: apps/v1
 kind: Deployment
 metadata:
   namespace: ${ZED_KUBE_NAMESPACE}
-  name: nginx
+  name: postgrest
+
 spec:
   replicas: 1
   selector:
     matchLabels:
-      app: nginx
+      app: postgrest
   template:
     metadata:
       labels:
-        app: nginx
-    spec:
-      containers:
-        - name: nginx
-          image: nginx:latest
-          ports:
-            - containerPort: 8080
-              protocol: TCP
-          volumeMounts:
-            - name: nginx-config
-              mountPath: /etc/nginx/nginx.conf
-              subPath: nginx.conf
-      volumes:
-        - name: nginx-config
-          configMap:
-            name: nginx-config
-
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  namespace: ${ZED_KUBE_NAMESPACE}
-  name: nginx-config
-data:
-  nginx.conf: |
-    events {}
-
-    http {
-      server {
-        listen 8080;
-
-        location /app/ {
-          proxy_pass http://postgrest-app:8080/;
-        }
-
-        location /llm/ {
-          proxy_pass http://postgrest-llm:8080/;
-        }
-      }
-    }
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  namespace: ${ZED_KUBE_NAMESPACE}
-  name: postgrest-app
-spec:
-  selector:
-    app: postgrest-app
-  ports:
-    - protocol: TCP
-      port: 8080
-      targetPort: 8080
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  namespace: ${ZED_KUBE_NAMESPACE}
-  name: postgrest-llm
-spec:
-  selector:
-    app: postgrest-llm
-  ports:
-    - protocol: TCP
-      port: 8080
-      targetPort: 8080
-
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  namespace: ${ZED_KUBE_NAMESPACE}
-  name: postgrest-app
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: postgrest-app
-  template:
-    metadata:
-      labels:
-        app: postgrest-app
+        app: postgrest
     spec:
       containers:
         - name: postgrest
@@ -137,39 +55,3 @@ spec:
                 secretKeyRef:
                   name: postgrest
                   key: jwt_secret
-
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  namespace: ${ZED_KUBE_NAMESPACE}
-  name: postgrest-llm
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: postgrest-llm
-  template:
-    metadata:
-      labels:
-        app: postgrest-llm
-    spec:
-      containers:
-        - name: postgrest
-          image: "postgrest/postgrest"
-          ports:
-            - containerPort: 8080
-              protocol: TCP
-          env:
-            - name: PGRST_SERVER_PORT
-              value: "8080"
-            - name: PGRST_DB_URI
-              valueFrom:
-                secretKeyRef:
-                  name: llm-database
-                  key: url
-            - name: PGRST_JWT_SECRET
-              valueFrom:
-                secretKeyRef:
-                  name: postgrest
-                  key: jwt_secret

crates/collab/migrations.sqlite/20221109000000_test_schema.sql

@@ -9,9 +9,7 @@ CREATE TABLE "users" (
     "connected_once" BOOLEAN NOT NULL DEFAULT false,
     "created_at" TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "metrics_id" TEXT,
-    "github_user_id" INTEGER,
-    "accepted_tos_at" TIMESTAMP WITHOUT TIME ZONE,
-    "github_user_created_at" TIMESTAMP WITHOUT TIME ZONE
+    "github_user_id" INTEGER
 );
 CREATE UNIQUE INDEX "index_users_github_login" ON "users" ("github_login");
 CREATE UNIQUE INDEX "index_invite_code_users" ON "users" ("invite_code");
@@ -295,8 +293,7 @@ CREATE UNIQUE INDEX "index_channel_buffer_collaborators_on_channel_id_connection
 
 CREATE TABLE "feature_flags" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "flag" TEXT NOT NULL UNIQUE,
-    "enabled_for_all" BOOLEAN NOT NULL DEFAULT false
+    "flag" TEXT NOT NULL UNIQUE
 );
 
 CREATE INDEX "index_feature_flags" ON "feature_flags" ("id");

crates/collab/migrations/20240812073542_add_accepted_tos_at.sql

@@ -1 +0,0 @@
-ALTER TABLE users ADD accepted_tos_at TIMESTAMP WITHOUT TIME ZONE;

crates/collab/migrations/20240812204045_add_github_user_created_at_to_users.sql

@@ -1 +0,0 @@
-ALTER TABLE "users" ADD COLUMN "github_user_created_at" TIMESTAMP WITHOUT TIME ZONE;

crates/collab/migrations/20240816181658_add_enabled_for_all_to_feature_flags.sql

@@ -1 +0,0 @@
-alter table feature_flags add column enabled_for_all boolean not null default false;

crates/collab/migrations_llm.sqlite/20240806182921_test_schema.sql

@@ -0,0 +1,32 @@
+create table providers (
+    id integer primary key autoincrement,
+    name text not null
+);
+
+create unique index uix_providers_on_name on providers (name);
+
+create table models (
+    id integer primary key autoincrement,
+    provider_id integer not null references providers (id) on delete cascade,
+    name text not null
+);
+
+create unique index uix_models_on_provider_id_name on models (provider_id, name);
+create index ix_models_on_provider_id on models (provider_id);
+create index ix_models_on_name on models (name);
+
+create table if not exists usages (
+    id integer primary key autoincrement,
+    user_id integer not null,
+    model_id integer not null references models (id) on delete cascade,
+    requests_this_minute integer not null default 0,
+    tokens_this_minute integer not null default 0,
+    requests_this_day integer not null default 0,
+    tokens_this_day integer not null default 0,
+    requests_this_month integer not null default 0,
+    tokens_this_month integer not null default 0
+);
+
+create index ix_usages_on_user_id on usages (user_id);
+create index ix_usages_on_model_id on usages (model_id);
+create unique index uix_usages_on_user_id_model_id on usages (user_id, model_id);

crates/collab/migrations_llm/20240806182921_create_providers_and_models.sql

@@ -8,10 +8,7 @@ create unique index uix_providers_on_name on providers (name);
 create table if not exists models (
     id serial primary key,
     provider_id integer not null references providers (id) on delete cascade,
-    name text not null,
-    max_requests_per_minute integer not null,
-    max_tokens_per_minute integer not null,
-    max_tokens_per_day integer not null
+    name text not null
 );
 
 create unique index uix_models_on_provider_id_name on models (provider_id, name);

crates/collab/migrations_llm/20240806213401_create_usages.sql

@@ -1,19 +1,15 @@
-create table usage_measures (
-    id serial primary key,
-    name text not null
-);
-
-create unique index uix_usage_measures_on_name on usage_measures (name);
-
 create table if not exists usages (
     id serial primary key,
     user_id integer not null,
     model_id integer not null references models (id) on delete cascade,
-    measure_id integer not null references usage_measures (id) on delete cascade,
-    timestamp timestamp without time zone not null,
-    buckets bigint[] not null
+    requests_this_minute integer not null default 0,
+    tokens_this_minute bigint not null default 0,
+    requests_this_day integer not null default 0,
+    tokens_this_day bigint not null default 0,
+    requests_this_month integer not null default 0,
+    tokens_this_month bigint not null default 0
 );
 
 create index ix_usages_on_user_id on usages (user_id);
 create index ix_usages_on_model_id on usages (model_id);
-create unique index uix_usages_on_user_id_model_id_measure_id on usages (user_id, model_id, measure_id);
+create unique index uix_usages_on_user_id_model_id on usages (user_id, model_id);

crates/collab/migrations_llm/20240809130000_change_rate_limit_columns_to_bigint.sql

@@ -1,4 +0,0 @@
-ALTER TABLE models
-    ALTER COLUMN max_requests_per_minute TYPE bigint,
-    ALTER COLUMN max_tokens_per_minute TYPE bigint,
-    ALTER COLUMN max_tokens_per_day TYPE bigint;

crates/collab/migrations_llm/20240809160000_add_pricing_columns_to_models.sql

@@ -1,3 +0,0 @@
-ALTER TABLE models
-    ADD COLUMN price_per_million_input_tokens integer NOT NULL DEFAULT 0,
-    ADD COLUMN price_per_million_output_tokens integer NOT NULL DEFAULT 0;

crates/collab/migrations_llm/20240812184444_add_is_staff_to_usages.sql

@@ -1 +0,0 @@
-alter table usages add column is_staff boolean not null default false;

crates/collab/migrations_llm/20240812225346_create_lifetime_usages.sql

@@ -1,9 +0,0 @@
-create table lifetime_usages (
-    id serial primary key,
-    user_id integer not null,
-    model_id integer not null references models (id) on delete cascade,
-    input_tokens bigint not null default 0,
-    output_tokens bigint not null default 0
-);
-
-create unique index uix_lifetime_usages_on_user_id_model_id on lifetime_usages (user_id, model_id);

crates/collab/migrations_llm/20240813002237_add_revoked_access_tokens_table.sql

@@ -1,7 +0,0 @@
-create table revoked_access_tokens (
-    id serial primary key,
-    jti text not null,
-    revoked_at timestamp without time zone not null default now()
-);
-
-create unique index uix_revoked_access_tokens_on_jti on revoked_access_tokens (jti);

crates/collab/postgrest_app.conf

@@ -1,4 +0,0 @@
-db-uri = "postgres://postgres@localhost/zed_llm"
-server-port = 8082
-jwt-secret = "the-postgrest-jwt-secret-for-authorization"
-log-level = "info"

crates/collab/src/api.rs

@@ -111,7 +111,6 @@ struct AuthenticatedUserParams {
     github_user_id: Option<i32>,
     github_login: String,
     github_email: Option<String>,
-    github_user_created_at: Option<chrono::DateTime<chrono::Utc>>,
 }
 
 #[derive(Debug, Serialize)]
@@ -132,7 +131,6 @@ async fn get_authenticated_user(
             &params.github_login,
             params.github_user_id,
             params.github_email.as_deref(),
-            params.github_user_created_at,
             initial_channel_id,
         )
         .await?;

crates/collab/src/api/contributors.rs

@@ -115,7 +115,6 @@ async fn add_contributor(
             &params.github_login,
             params.github_user_id,
             params.github_email.as_deref(),
-            params.github_user_created_at,
             initial_channel_id,
         )
         .await

crates/collab/src/api/events.rs

@@ -1,6 +1,5 @@
 use super::ips_file::IpsFile;
 use crate::api::CloudflareIpCountryHeader;
-use crate::clickhouse::write_to_table;
 use crate::{api::slack, AppState, Error, Result};
 use anyhow::{anyhow, Context};
 use aws_sdk_s3::primitives::ByteStream;
@@ -530,12 +529,12 @@ struct ToUpload {
 impl ToUpload {
     pub async fn upload(&self, clickhouse_client: &clickhouse::Client) -> anyhow::Result<()> {
         const EDITOR_EVENTS_TABLE: &str = "editor_events";
-        write_to_table(EDITOR_EVENTS_TABLE, &self.editor_events, clickhouse_client)
+        Self::upload_to_table(EDITOR_EVENTS_TABLE, &self.editor_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{EDITOR_EVENTS_TABLE}'"))?;
 
         const INLINE_COMPLETION_EVENTS_TABLE: &str = "inline_completion_events";
-        write_to_table(
+        Self::upload_to_table(
             INLINE_COMPLETION_EVENTS_TABLE,
             &self.inline_completion_events,
             clickhouse_client,
@@ -544,7 +543,7 @@ impl ToUpload {
         .with_context(|| format!("failed to upload to table '{INLINE_COMPLETION_EVENTS_TABLE}'"))?;
 
         const ASSISTANT_EVENTS_TABLE: &str = "assistant_events";
-        write_to_table(
+        Self::upload_to_table(
             ASSISTANT_EVENTS_TABLE,
             &self.assistant_events,
             clickhouse_client,
@@ -553,27 +552,27 @@ impl ToUpload {
         .with_context(|| format!("failed to upload to table '{ASSISTANT_EVENTS_TABLE}'"))?;
 
         const CALL_EVENTS_TABLE: &str = "call_events";
-        write_to_table(CALL_EVENTS_TABLE, &self.call_events, clickhouse_client)
+        Self::upload_to_table(CALL_EVENTS_TABLE, &self.call_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{CALL_EVENTS_TABLE}'"))?;
 
         const CPU_EVENTS_TABLE: &str = "cpu_events";
-        write_to_table(CPU_EVENTS_TABLE, &self.cpu_events, clickhouse_client)
+        Self::upload_to_table(CPU_EVENTS_TABLE, &self.cpu_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{CPU_EVENTS_TABLE}'"))?;
 
         const MEMORY_EVENTS_TABLE: &str = "memory_events";
-        write_to_table(MEMORY_EVENTS_TABLE, &self.memory_events, clickhouse_client)
+        Self::upload_to_table(MEMORY_EVENTS_TABLE, &self.memory_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{MEMORY_EVENTS_TABLE}'"))?;
 
         const APP_EVENTS_TABLE: &str = "app_events";
-        write_to_table(APP_EVENTS_TABLE, &self.app_events, clickhouse_client)
+        Self::upload_to_table(APP_EVENTS_TABLE, &self.app_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{APP_EVENTS_TABLE}'"))?;
 
         const SETTING_EVENTS_TABLE: &str = "setting_events";
-        write_to_table(
+        Self::upload_to_table(
             SETTING_EVENTS_TABLE,
             &self.setting_events,
             clickhouse_client,
@@ -582,7 +581,7 @@ impl ToUpload {
         .with_context(|| format!("failed to upload to table '{SETTING_EVENTS_TABLE}'"))?;
 
         const EXTENSION_EVENTS_TABLE: &str = "extension_events";
-        write_to_table(
+        Self::upload_to_table(
             EXTENSION_EVENTS_TABLE,
             &self.extension_events,
             clickhouse_client,
@@ -591,22 +590,48 @@ impl ToUpload {
         .with_context(|| format!("failed to upload to table '{EXTENSION_EVENTS_TABLE}'"))?;
 
         const EDIT_EVENTS_TABLE: &str = "edit_events";
-        write_to_table(EDIT_EVENTS_TABLE, &self.edit_events, clickhouse_client)
+        Self::upload_to_table(EDIT_EVENTS_TABLE, &self.edit_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{EDIT_EVENTS_TABLE}'"))?;
 
         const ACTION_EVENTS_TABLE: &str = "action_events";
-        write_to_table(ACTION_EVENTS_TABLE, &self.action_events, clickhouse_client)
+        Self::upload_to_table(ACTION_EVENTS_TABLE, &self.action_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{ACTION_EVENTS_TABLE}'"))?;
 
         const REPL_EVENTS_TABLE: &str = "repl_events";
-        write_to_table(REPL_EVENTS_TABLE, &self.repl_events, clickhouse_client)
+        Self::upload_to_table(REPL_EVENTS_TABLE, &self.repl_events, clickhouse_client)
             .await
             .with_context(|| format!("failed to upload to table '{REPL_EVENTS_TABLE}'"))?;
 
         Ok(())
     }
+
+    async fn upload_to_table<T: clickhouse::Row + Serialize + std::fmt::Debug>(
+        table: &str,
+        rows: &[T],
+        clickhouse_client: &clickhouse::Client,
+    ) -> anyhow::Result<()> {
+        if rows.is_empty() {
+            return Ok(());
+        }
+
+        let mut insert = clickhouse_client.insert(table)?;
+
+        for event in rows {
+            insert.write(event).await?;
+        }
+
+        insert.end().await?;
+
+        let event_count = rows.len();
+        log::info!(
+            "wrote {event_count} {event_specifier} to '{table}'",
+            event_specifier = if event_count == 1 { "event" } else { "events" }
+        );
+
+        Ok(())
+    }
 }
 
 pub fn serialize_country_code<S>(country_code: &str, serializer: S) -> Result<S::Ok, S::Error>

crates/collab/src/clickhouse.rs

@@ -1,28 +0,0 @@
-use serde::Serialize;
-
-/// Writes the given rows to the specified Clickhouse table.
-pub async fn write_to_table<T: clickhouse::Row + Serialize + std::fmt::Debug>(
-    table: &str,
-    rows: &[T],
-    clickhouse_client: &clickhouse::Client,
-) -> anyhow::Result<()> {
-    if rows.is_empty() {
-        return Ok(());
-    }
-
-    let mut insert = clickhouse_client.insert(table)?;
-
-    for event in rows {
-        insert.write(event).await?;
-    }
-
-    insert.end().await?;
-
-    let event_count = rows.len();
-    log::info!(
-        "wrote {event_count} {event_specifier} to '{table}'",
-        event_specifier = if event_count == 1 { "event" } else { "events" }
-    );
-
-    Ok(())
-}

crates/collab/src/db/queries/contributors.rs

@@ -65,7 +65,6 @@ impl Database {
         github_login: &str,
         github_user_id: Option<i32>,
         github_email: Option<&str>,
-        github_user_created_at: Option<DateTimeUtc>,
         initial_channel_id: Option<ChannelId>,
     ) -> Result<()> {
         self.transaction(|tx| async move {
@@ -74,7 +73,6 @@ impl Database {
                     github_login,
                     github_user_id,
                     github_email,
-                    github_user_created_at.map(|time| time.naive_utc()),
                     initial_channel_id,
                     &tx,
                 )

crates/collab/src/db/queries/notifications.rs

@@ -5,27 +5,15 @@ use util::ResultExt;
 impl Database {
     /// Initializes the different kinds of notifications by upserting records for them.
     pub async fn initialize_notification_kinds(&mut self) -> Result<()> {
-        let all_kinds = Notification::all_variant_names();
-        let existing_kinds = notification_kind::Entity::find().all(&self.pool).await?;
-
-        let kinds_to_create: Vec<_> = all_kinds
-            .iter()
-            .filter(|&kind| {
-                !existing_kinds
-                    .iter()
-                    .any(|existing| existing.name == **kind)
-            })
-            .map(|kind| notification_kind::ActiveModel {
+        notification_kind::Entity::insert_many(Notification::all_variant_names().iter().map(
+            |kind| notification_kind::ActiveModel {
                 name: ActiveValue::Set(kind.to_string()),
                 ..Default::default()
-            })
-            .collect();
-
-        if !kinds_to_create.is_empty() {
-            notification_kind::Entity::insert_many(kinds_to_create)
-                .exec_without_returning(&self.pool)
-                .await?;
-        }
+            },
+        ))
+        .on_conflict(OnConflict::new().do_nothing().to_owned())
+        .exec_without_returning(&self.pool)
+        .await?;
 
         let mut rows = notification_kind::Entity::find().stream(&self.pool).await?;
         while let Some(row) = rows.next().await {

crates/collab/src/db/queries/users.rs

@@ -1,5 +1,3 @@
-use chrono::NaiveDateTime;
-
 use super::*;
 
 impl Database {
@@ -101,7 +99,6 @@ impl Database {
         github_login: &str,
         github_user_id: Option<i32>,
         github_email: Option<&str>,
-        github_user_created_at: Option<DateTimeUtc>,
         initial_channel_id: Option<ChannelId>,
     ) -> Result<User> {
         self.transaction(|tx| async move {
@@ -109,7 +106,6 @@ impl Database {
                 github_login,
                 github_user_id,
                 github_email,
-                github_user_created_at.map(|created_at| created_at.naive_utc()),
                 initial_channel_id,
                 &tx,
             )
@@ -123,7 +119,6 @@ impl Database {
         github_login: &str,
         github_user_id: Option<i32>,
         github_email: Option<&str>,
-        github_user_created_at: Option<NaiveDateTime>,
         initial_channel_id: Option<ChannelId>,
         tx: &DatabaseTransaction,
     ) -> Result<User> {
@@ -135,10 +130,6 @@ impl Database {
             {
                 let mut user_by_github_user_id = user_by_github_user_id.into_active_model();
                 user_by_github_user_id.github_login = ActiveValue::set(github_login.into());
-                if github_user_created_at.is_some() {
-                    user_by_github_user_id.github_user_created_at =
-                        ActiveValue::set(github_user_created_at);
-                }
                 Ok(user_by_github_user_id.update(tx).await?)
             } else if let Some(user_by_github_login) = user::Entity::find()
                 .filter(user::Column::GithubLogin.eq(github_login))
@@ -147,17 +138,12 @@ impl Database {
             {
                 let mut user_by_github_login = user_by_github_login.into_active_model();
                 user_by_github_login.github_user_id = ActiveValue::set(Some(github_user_id));
-                if github_user_created_at.is_some() {
-                    user_by_github_login.github_user_created_at =
-                        ActiveValue::set(github_user_created_at);
-                }
                 Ok(user_by_github_login.update(tx).await?)
             } else {
                 let user = user::Entity::insert(user::ActiveModel {
                     email_address: ActiveValue::set(github_email.map(|email| email.into())),
                     github_login: ActiveValue::set(github_login.into()),
                     github_user_id: ActiveValue::set(Some(github_user_id)),
-                    github_user_created_at: ActiveValue::set(github_user_created_at),
                     admin: ActiveValue::set(false),
                     invite_count: ActiveValue::set(0),
                     invite_code: ActiveValue::set(None),
@@ -239,26 +225,6 @@ impl Database {
         .await
     }
 
-    /// Sets "accepted_tos_at" on the user to the given timestamp.
-    pub async fn set_user_accepted_tos_at(
-        &self,
-        id: UserId,
-        accepted_tos_at: Option<DateTime>,
-    ) -> Result<()> {
-        self.transaction(|tx| async move {
-            user::Entity::update_many()
-                .filter(user::Column::Id.eq(id))
-                .set(user::ActiveModel {
-                    accepted_tos_at: ActiveValue::set(accepted_tos_at),
-                    ..Default::default()
-                })
-                .exec(&*tx)
-                .await?;
-            Ok(())
-        })
-        .await
-    }
-
     /// hard delete the user.
     pub async fn destroy_user(&self, id: UserId) -> Result<()> {
         self.transaction(|tx| async move {
@@ -312,11 +278,10 @@ impl Database {
     }
 
     /// Creates a new feature flag.
-    pub async fn create_user_flag(&self, flag: &str, enabled_for_all: bool) -> Result<FlagId> {
+    pub async fn create_user_flag(&self, flag: &str) -> Result<FlagId> {
         self.transaction(|tx| async move {
             let flag = feature_flag::Entity::insert(feature_flag::ActiveModel {
                 flag: ActiveValue::set(flag.to_string()),
-                enabled_for_all: ActiveValue::set(enabled_for_all),
                 ..Default::default()
             })
             .exec(&*tx)
@@ -351,15 +316,7 @@ impl Database {
                 Flag,
             }
 
-            let flags_enabled_for_all = feature_flag::Entity::find()
-                .filter(feature_flag::Column::EnabledForAll.eq(true))
-                .select_only()
-                .column(feature_flag::Column::Flag)
-                .into_values::<_, QueryAs>()
-                .all(&*tx)
-                .await?;
-
-            let flags_enabled_for_user = user::Model {
+            let flags = user::Model {
                 id: user,
                 ..Default::default()
             }
@@ -370,10 +327,7 @@ impl Database {
             .all(&*tx)
             .await?;
 
-            let mut all_flags = HashSet::from_iter(flags_enabled_for_all);
-            all_flags.extend(flags_enabled_for_user);
-
-            Ok(all_flags.into_iter().collect())
+            Ok(flags)
         })
         .await
     }

crates/collab/src/db/tables/feature_flag.rs

@@ -8,7 +8,6 @@ pub struct Model {
     #[sea_orm(primary_key)]
     pub id: FlagId,
     pub flag: String,
-    pub enabled_for_all: bool,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/tables/user.rs

@@ -1,5 +1,4 @@
 use crate::db::UserId;
-use chrono::NaiveDateTime;
 use sea_orm::entity::prelude::*;
 use serde::Serialize;
 
@@ -11,7 +10,6 @@ pub struct Model {
     pub id: UserId,
     pub github_login: String,
     pub github_user_id: Option<i32>,
-    pub github_user_created_at: Option<NaiveDateTime>,
     pub email_address: Option<String>,
     pub admin: bool,
     pub invite_code: Option<String>,
@@ -19,8 +17,7 @@ pub struct Model {
     pub inviter_id: Option<UserId>,
     pub connected_once: bool,
     pub metrics_id: Uuid,
-    pub created_at: NaiveDateTime,
-    pub accepted_tos_at: Option<NaiveDateTime>,
+    pub created_at: DateTime,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/tests.rs

@@ -10,7 +10,6 @@ mod extension_tests;
 mod feature_flag_tests;
 mod message_tests;
 mod processed_stripe_event_tests;
-mod user_tests;
 
 use crate::migrations::run_database_migrations;
 

crates/collab/src/db/tests/contributor_tests.rs

@@ -1,5 +1,3 @@
-use chrono::Utc;
-
 use super::Database;
 use crate::{db::NewUserParams, test_both_dbs};
 use std::sync::Arc;
@@ -24,8 +22,7 @@ async fn test_contributors(db: &Arc<Database>) {
 
     assert_eq!(db.get_contributors().await.unwrap(), Vec::<String>::new());
 
-    let user1_created_at = Utc::now();
-    db.add_contributor("user1", Some(1), None, Some(user1_created_at), None)
+    db.add_contributor("user1", Some(1), None, None)
         .await
         .unwrap();
     assert_eq!(
@@ -33,8 +30,7 @@ async fn test_contributors(db: &Arc<Database>) {
         vec!["user1".to_string()]
     );
 
-    let user2_created_at = Utc::now();
-    db.add_contributor("user2", Some(2), None, Some(user2_created_at), None)
+    db.add_contributor("user2", Some(2), None, None)
         .await
         .unwrap();
     assert_eq!(

crates/collab/src/db/tests/db_tests.rs

@@ -1,6 +1,5 @@
 use super::*;
 use crate::test_both_dbs;
-use chrono::Utc;
 use pretty_assertions::{assert_eq, assert_ne};
 use std::sync::Arc;
 
@@ -101,13 +100,7 @@ async fn test_get_or_create_user_by_github_account(db: &Arc<Database>) {
         .user_id;
 
     let user = db
-        .get_or_create_user_by_github_account(
-            "the-new-login2",
-            Some(102),
-            None,
-            Some(Utc::now()),
-            None,
-        )
+        .get_or_create_user_by_github_account("the-new-login2", Some(102), None, None)
         .await
         .unwrap();
     assert_eq!(user.id, user_id2);
@@ -115,13 +108,7 @@ async fn test_get_or_create_user_by_github_account(db: &Arc<Database>) {
     assert_eq!(user.github_user_id, Some(102));
 
     let user = db
-        .get_or_create_user_by_github_account(
-            "login3",
-            Some(103),
-            Some("user3@example.com"),
-            Some(Utc::now()),
-            None,
-        )
+        .get_or_create_user_by_github_account("login3", Some(103), Some("user3@example.com"), None)
         .await
         .unwrap();
     assert_eq!(&user.github_login, "login3");

crates/collab/src/db/tests/feature_flag_tests.rs

@@ -2,7 +2,6 @@ use crate::{
     db::{Database, NewUserParams},
     test_both_dbs,
 };
-use pretty_assertions::assert_eq;
 use std::sync::Arc;
 
 test_both_dbs!(
@@ -38,27 +37,22 @@ async fn test_get_user_flags(db: &Arc<Database>) {
         .unwrap()
         .user_id;
 
-    const FEATURE_FLAG_ONE: &str = "brand-new-ux";
-    const FEATURE_FLAG_TWO: &str = "cool-feature";
-    const FEATURE_FLAG_THREE: &str = "feature-enabled-for-everyone";
+    const CHANNELS_ALPHA: &str = "channels-alpha";
+    const NEW_SEARCH: &str = "new-search";
 
-    let feature_flag_one = db.create_user_flag(FEATURE_FLAG_ONE, false).await.unwrap();
-    let feature_flag_two = db.create_user_flag(FEATURE_FLAG_TWO, false).await.unwrap();
-    db.create_user_flag(FEATURE_FLAG_THREE, true).await.unwrap();
+    let channels_flag = db.create_user_flag(CHANNELS_ALPHA).await.unwrap();
+    let search_flag = db.create_user_flag(NEW_SEARCH).await.unwrap();
 
-    db.add_user_flag(user_1, feature_flag_one).await.unwrap();
-    db.add_user_flag(user_1, feature_flag_two).await.unwrap();
+    db.add_user_flag(user_1, channels_flag).await.unwrap();
+    db.add_user_flag(user_1, search_flag).await.unwrap();
 
-    db.add_user_flag(user_2, feature_flag_one).await.unwrap();
+    db.add_user_flag(user_2, channels_flag).await.unwrap();
 
     let mut user_1_flags = db.get_user_flags(user_1).await.unwrap();
     user_1_flags.sort();
-    assert_eq!(
-        user_1_flags,
-        &[FEATURE_FLAG_ONE, FEATURE_FLAG_TWO, FEATURE_FLAG_THREE]
-    );
+    assert_eq!(user_1_flags, &[CHANNELS_ALPHA, NEW_SEARCH]);
 
     let mut user_2_flags = db.get_user_flags(user_2).await.unwrap();
     user_2_flags.sort();
-    assert_eq!(user_2_flags, &[FEATURE_FLAG_ONE, FEATURE_FLAG_THREE]);
+    assert_eq!(user_2_flags, &[CHANNELS_ALPHA]);
 }

crates/collab/src/db/tests/user_tests.rs

@@ -1,45 +0,0 @@
-use chrono::Utc;
-
-use crate::{
-    db::{Database, NewUserParams},
-    test_both_dbs,
-};
-use std::sync::Arc;
-
-test_both_dbs!(
-    test_accepted_tos,
-    test_accepted_tos_postgres,
-    test_accepted_tos_sqlite
-);
-
-async fn test_accepted_tos(db: &Arc<Database>) {
-    let user_id = db
-        .create_user(
-            "user1@example.com",
-            false,
-            NewUserParams {
-                github_login: "user1".to_string(),
-                github_user_id: 1,
-            },
-        )
-        .await
-        .unwrap()
-        .user_id;
-
-    let user = db.get_user_by_id(user_id).await.unwrap().unwrap();
-    assert!(user.accepted_tos_at.is_none());
-
-    let accepted_tos_at = Utc::now().naive_utc();
-    db.set_user_accepted_tos_at(user_id, Some(accepted_tos_at))
-        .await
-        .unwrap();
-
-    let user = db.get_user_by_id(user_id).await.unwrap().unwrap();
-    assert!(user.accepted_tos_at.is_some());
-    assert_eq!(user.accepted_tos_at, Some(accepted_tos_at));
-
-    db.set_user_accepted_tos_at(user_id, None).await.unwrap();
-
-    let user = db.get_user_by_id(user_id).await.unwrap().unwrap();
-    assert!(user.accepted_tos_at.is_none());
-}