start adding icons for copying files and folders in the explorer

Daily UI improvements

.devcontainer/README.md

@@ -56,7 +56,7 @@ Next: **[Try it out!](#try-it)**
 
 You may see improved VNC responsiveness when accessing a codespace from VS Code client since you can use a [VNC Viewer][def]. Here's how to do it.
 
-1. Install [Visual Studio Code Stable](https://code.visualstudio.com/) or [Insiders](https://code.visualstudio.com/insiders/) and the the [GitHub Codespaces extension](https://marketplace.visualstudio.com/items?itemName=GitHub.codespaces).
+1. Install [Visual Studio Code Stable](https://code.visualstudio.com/) or [Insiders](https://code.visualstudio.com/insiders/) and the [GitHub Codespaces extension](https://marketplace.visualstudio.com/items?itemName=GitHub.codespaces).
 
     > **Note:** The GitHub Codespaces extension requires the Visual Studio Code distribution of Code - OSS.
 

.eslintrc.json

@@ -10,6 +10,7 @@
 		"jsdoc",
 		"header",
 		"local"
+		// "react" // Void
 	],
 	"rules": {
 		"constructor-super": "warn",

.gitignore

@@ -21,3 +21,4 @@ vscode.db
 product.overrides.json
 *.snap.actual
 .vscode-test
+.tmp/

.idx/dev.nix

@@ -0,0 +1,48 @@
+# Created for Void
+# To learn more about how to use Nix to configure your environment
+# see: https://developers.google.com/idx/guides/customize-idx-env
+{pkgs}: {
+  # Which nixpkgs channel to use.
+  channel = "stable-23.11"; # or "unstable"
+  # Use https://search.nixos.org/packages to find packages
+  packages = [
+    pkgs.nodejs_20
+    pkgs.yarn
+    pkgs.nodePackages.pnpm
+    pkgs.bun
+    pkgs.gh
+  ];
+  # Sets environment variables in the workspace
+  env = {};
+  idx = {
+    # Search for the extensions you want on https://open-vsx.org/ and use "publisher.id"
+    extensions = [
+      # "vscodevim.vim"
+    ];
+    workspace = {
+      # Runs when a workspace is first created with this `dev.nix` file
+      onCreate = {
+        npm-install = "npm ci --no-audit --prefer-offline --no-progress --timing";
+        # Open editors for the following files by default, if they exist:
+        default.openFiles = [
+          # Cover all the variations of language, src-dir, router (app/pages)
+          "pages/index.tsx" "pages/index.jsx"
+          "src/pages/index.tsx" "src/pages/index.jsx"
+          "app/page.tsx" "app/page.jsx"
+          "src/app/page.tsx" "src/app/page.jsx"
+        ];
+      };
+      # To run something each time the workspace is (re)started, use the `onStart` hook
+    };
+    # Enable previews and customize configuration
+    previews = {
+      enable = true;
+      previews = {
+        web = {
+          command = ["npm" "run" "dev" "--" "--port" "$PORT" "--hostname" "0.0.0.0"];
+          manager = "web";
+        };
+      };
+    };
+  };
+}

CONTRIBUTING.md

@@ -1,150 +1,121 @@
 # Contributing to Void
 
-Welcome! 👋 This is a guide on how to contribute to Void. We want to make it as easy as possible to contribute, so if you have any questions or comments, reach out via email or discord!
+Welcome! 👋 This is the official guide on how to contribute to Void. We want to make it as easy as possible to contribute, so if you have any questions or comments, reach out via email or discord!
 
-There are two main ways to contribute:
+There are a few ways to contribute:
 
-- Suggest New Features ([discord](https://discord.gg/RSNjgaugJs))
-- Build New Features ([project](https://github.com/orgs/voideditor/projects/2/views/3))
+- 👨‍💻 Build new features - see [Issues](https://github.com/voideditor/void/issues).
+- 💡 Make suggestions in our [Discord](https://discord.gg/RSNjgaugJs).
+- ⭐️ If you want to build your AI tool into Void, feel free to get in touch! It's very easy to extend Void, and the UX you create will be much more natural than a VSCode Extension.
 
-We use a [VSCode extension](https://code.visualstudio.com/api/get-started/your-first-extension) to implement most of Void's functionality. Scroll down to see 1. How to build/contribute to the Extension, or 2. How to build/contribute to the full IDE (for more native changes).
+Most of Void's code lives in `src/vs/workbench/contrib/void/browser/` and `src/vs/platform/void/`.
 
-For some useful links we've compiled see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).
 
-## 1. Building the Extension
-Here's how you can start contributing to the Void extension. This is where you should get started if you're new.
 
-1. Clone the repository:
+## Building the full IDE
+
+### a. Build Prerequisites - Mac
+
+If you're using a Mac, you need Python and XCode. You probably have these by default.
+
+### b. Build Prerequisites - Windows
+
+If you're using a Windows computer, first get [Visual Studio 2022](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community) (recommended) or [VS Build Tools](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools) (not recommended). If you already have both, you might need to run the next few steps on both of them.
+
+Go to the "Workloads" tab and select:
+- `Desktop development with C++`
+- `Node.js build tools`
+
+Go to the "Individual Components" tab and select:
+- `MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs (Latest)`
+- `C++ ATL for latest build tools with Spectre Mitigations`
+- `C++ MFC for latest build tools with Spectre Mitigations`
+
+Finally, click Install.
+
+### c. Build Prerequisites - Linux
+
+First, run `npm install -g node-gyp`. Then:
+
+- Debian (Ubuntu, etc): `sudo apt-get install build-essential g++ libx11-dev libxkbfile-dev libsecret-1-dev libkrb5-dev python-is-python3`.
+- Red Hat (Fedora, etc): `sudo dnf install @development-tools gcc gcc-c++ make libsecret-devel krb5-devel libX11-devel libxkbfile-devel`.
+- Others: see [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute).
+
+### Building Void
+
+To build Void, open `void/` inside VSCode. Then open your terminal and run:
+
+1. `npm install` to install all dependencies.
+2. `npm run watchreact` to build Void's browser dependencies like React.
+3. Build Void.
+	 - Press <kbd>Cmd+Shift+B</kbd> (Mac).
+   - Press <kbd>Ctrl+Shift+B</kbd> (Windows/Linux).
+   - This step can take ~5 min. The build is done when you see two check marks.
+4. Run Void.
+	 - Run `./scripts/code.sh` (Mac/Linux).
+   - Run `./scripts/code.bat` (Windows).
+   - This command should open up the built IDE. You can always press <kbd>Ctrl+R</kbd> (<kbd>Cmd+R</kbd>)  inside the new window to see changes without re-building, or press or <kbd>Ctrl+Shift+P</kbd> in the new window and run "Reload Window".
+	- If you would like to reset Void back to its default settings, you can run `./scripts/code.sh --user-data-dir ./.tmp/user-data --extensions-dir ./.tmp/extensions` (mac). This will save all data and extensions to the `.tmp` folder. You can delete this folder to reset your settings.
+
+#### Building Void from Terminal
+
+Alternatively, if you want to build Void from the terminal, instead of pressing <kbd>Cmd+Shift+B</kbd> you can run `npm run watch`. The build is done when you see something like this:
 
 ```
-git clone https://github.com/voideditor/void
+[watch-extensions] [00:37:39] Finished compilation extensions with 0 errors after 19303 ms
+[watch-client    ] [00:38:06] Finished compilation with 0 errors after 46248 ms
+[watch-client    ] [00:38:07] Starting compilation...
+[watch-client    ] [00:38:07] Finished compilation with 0 errors after 5 ms
 ```
 
-2. Open the folder `/extensions/void` in VS Code (open it in a new workspace, *don't* just cd into it):
 
-```
-open /extensions/void
-```
 
-3. Install dependencies:
+### Common Fixes
 
-```
-npm install
-```
+- Make sure you follow the prerequisite steps.
+- Make sure you have the same NodeJS version as `.nvmrc`.
+- Make sure your `npm run watchreact` is running if you change any React files, or else you'll need to re-build.
+- If you see missing styles, go to `src2/styles.css` and re-save the file.
+- If you get `"TypeError: Failed to fetch dynamically imported module: vscode-file://vscode-app/.../workbench.desktop.main.js", source: file:///.../bootstrap-window.js`, make sure all imports end with `.js`.
+- If you have any questions, feel free to [submit an issue](https://github.com/voideditor/void/issues/new). For building questions, you can also refer to VSCode's full [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page.
 
-4. Build the project. We created this build command so that we could run React in vscode - it converts `sidebar/index.tsx` into a CSS/JS bundle in `dist/`.
 
-```
-npm run build
-```
 
-5. Run the project by pressing <kbd>F5</kbd>.
+## Bundling
 
-This will start a new instance of VS Code with the extension enabled. If this does not work, you can press <kbd>Ctrl+Shift+P</kbd>, select "Debug: Start Debugging", and select "VS Code Extension Development".
+We don't usually recommend bundling. Instead, you should probably just build. If you're sure you want to bundle Void into an executable app, make sure you've built first, then run one of the following commands. This will create a folder named `VSCode-darwin-arm64` (or similar) in the repo's parent's directory. Be patient - compiling can take ~25 minutes.
 
-If you would like to use AI features, you need to provide an API key. You can do that by going to Settings (Ctrl+,) typing in "void", and adding the API key you want to use (eg. the `"Anthropic Api Key"` environment variable). The "Which API" environment variable controls the provider and defaults to "anthropic".
+### Mac
+- `npm run gulp vscode-darwin-arm64` - most common (Apple Silicon)
+- `npm run gulp vscode-darwin-x64` (Intel)
 
-Now that you're set up, feel free to check out our [Issues](https://github.com/voideditor/void/issues) page!
+### Windows
+- `npm run gulp vscode-win32-x64` - most common
+- `npm run gulp vscode-win32-ia32`
 
-## 2. Building the full IDE
+### Linux
+- `npm run gulp vscode-linux-x64` - most common
+- `npm run gulp vscode-linux-arm`
+- `npm run gulp vscode-linux-ia32`
 
-Beyond the extension, we very occasionally edit the IDE when we need to access more functionality. If you want to work on the full IDE, please follow the steps below, or see VS Code's full [how to contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page.
 
-Before starting, make sure you've built the extension (by running `cd .\extensions\void\` and `npm run build`). Also make sure you have Python on your system.
-
-Make sure you're on the correct NodeJS version as per `.nvmrc`.
-
-1. Install all dependencies.
-
-```
-npm install
-```
-
-2. In VS Code, press <kbd>Ctrl+Shift+B</kbd> to start the build process - this can take some time. If you're not using VS Code, run `npm run watch` instead.
-
-3. Run `./scripts/code.sh` in your terminal.
-
-This should open up the built IDE after loading for some time. To see new changes without restarting the build, use <kbd>Ctrl+Shift+P</kbd> and run "Reload Window".
-
-To bundle the IDE, run `npm run gulp vscode-darwin-arm64`. Here are the full options: `vscode-{win32-ia32 | win32-x64 | darwin-x64 | darwin-arm64 | linux-ia32 | linux-x64 | linux-arm}(-min)`
-
-If you're on Windows, we recommend running the project inside a dev container. VSCode should prompt you to do this automatically.
-
-Now that you're set up, feel free to check out our [Issues](https://github.com/voideditor/void/issues) page!
-
-## Roadmap
-
-Here are the most important topics on our Roadmap. More ⭐'s = more important.
-
-## ⭐⭐⭐ Improve diffs.
-
-We define a "diff" as a single green/red pair that denotes a change. Here are improvements to make:
-
-1. Show deletion (-) diffs. Right now we're only showing insertion (+) diffs. Diffs currently work by highlighting all of the new code in green with a simple text decoration. Instead, we would like to use code from VS Code's native diffEditor to show the diffs ("inline" mode). We could alternatively keep what we have and add red zones of the deleted code to indicate a deletion diff (-).
-
-2. Fix bugginess when the user presses "Accept" or "Reject" on a diff. One issue is that when a diff is accepted/rejected all of the diffs below should be updated (because they are now on different line numbers). There are other miscellaneous issues too.
-
-3. Make diff highlighting dynamic. Right now when the user edits text, all of the diffs and their highlights are cleared. Instead, we should update the highlighting of the diff. Each diff lives on a range of lines, and all changes inside that range or intersecting with it should update its highlighting.
-
-## ⭐⭐⭐ Build Cursor-style quick edits (ctrl+k).
-
-When the user presses ctrl+k, an input box should appear inline with the code that they were selecting. This is somewhat difficult to do because an extension alone cannot do this, and it requires creating a new component in the IDE. We think you can modify vscode's built-in "codelens" or "zone widget" components, but we are open to alternatives.
-
-## ⭐⭐⭐ Make History work well.
-
-When the user submits a response or presses the apply/accept/reject button, we should add these events to the history, allowing the user to undo/redo them. Right now there is unexpected behavior if the user tries to undo or redo their changes.
-
-## ⭐⭐⭐ Improve Ctrl+L backend.
-
-Right now, the model outputs entire files. Instead, we should change the prompt so that the model outputs partial changes like `// ... rest of file`. When the user clicks the "Apply" button, the model should rewrite the file and apply the partial changes in the correct locations.
-
-## ⭐⭐ Integrate with Ollama.
-
-We have an Ollama integration coded up in the extension, but it breaks. This is because Ollama has Node.js dependencies like 'path' and 'os' which cannot run in extensions (extensions have to be able to run in the browser). To fix this, we need to migrate Void's extension so that it runs natively into the VS Code editor so that we can access Node.js.
-
-## ⭐⭐⭐ Creative.
-
-Feel free to build AI features beyond the standard Cursor ones. For example, creating better code search, or supporting AI agents that can edit across files and make multiple LLM calls.
-
-Eventually, we want to build a convenient API for creating AI tools. The API will provide methods for creating the UI (showing an autocomplete suggestion, or creating a new diff), detecting event changes (like `onKeystroke` or `onFileOpen`), and modifying the user's file-system (storing indexes associated with each file), making it much easier to make your own AI plugin. We plan on building these features further along in timeline, but we wanted to list them for completeness.
-
-## ⭐ One-stars.
-
-⭐ When user presses ctrl+L it should clear the sidebar's state.
-
-⭐ Let the user accept / reject all Diffs in an entire file via the sidebar.
-
-⭐ Allow the user to make multiple selections of code or files at once.
-
-⭐ Allow user to X out of their current selection.
 
 # Guidelines
 
-Please don't make big refactors without speaking with us first. We'd like to keep the codebase similar to vscode so we can periodically rebase, and if we have big changes that gets complicated.
+We're always glad to talk about new ideas, help you get set up, and make sure your changes align with our vision for the project! Feel free to shoot Mat or Andrew a message, or start chatting with us in the `#contributing` channel of our [Discord](https://discord.gg/RSNjgaugJs).
 
-# Submitting a Pull Request
 
-Please submit a pull request once you've made a change. Here are a few guidelines:
+## Submitting a Pull Request
 
-- A PR should be about one *single* feature change. The fewer items you change, the more likely the PR is to be accepted.
+- Please submit a pull request once you've made a change. No need to submit an Issue unless you're creating a new feature.
+- Please don't use AI to write your PR 🙂.
 
-- Your PR should contain a description that first explains at a high level what you did, and then describes the exact changes you made (and to which files). Please don't use vague statements like "refactored code" or "improved types" (instead, describe what code you refactored, or what types you changed). 
-
-- Your title should clearly describe the change you made.
-
-- Add tags to help us stay organized!
-
-- Please don't open a new Issue for your PR. Just submit the PR.
-
-- Avoid refactoring and making feature changes in the same PR. 
-
-- Write good code. For example, a common mistake when people edit Void's config is to hard-code a default value like `'claude-3.5'` in 2+ separate places. Please follow best practices or describe your thought process if you had to compromise.
 
+<!--
 # Relevant files
 
 We keep track of all the files we've changed with Void so it's easy to rebase:
 
-
 - README.md
 - CONTRIBUTING.md
 - VOID_USEFUL_LINKS.md
@@ -153,12 +124,19 @@ We keep track of all the files we've changed with Void so it's easy to rebase:
 
 - src/vs/workbench/api/common/{extHost.api.impl.ts | extHostApiCommands.ts}
 - src/vs/workbench/workbench.common.main.ts
-- src/vs/workbench/contrib/void
-- extensions/void
+- src/vs/workbench/contrib/void/\*
+- extensions/void/\*
 
-- .github/
-- .vscode/settings
+- .github/\*
+- .vscode/settings/\*
 - .eslintrc.json
 - build/hygiene.js
 - build/lib/i18n.resources.json
 - build/npm/dirs.js
+
+- vscode.proposed.editorInsets.d.ts - not modified, but code copied
+-->
+
+## References
+
+For some useful links we've compiled on VSCode, see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).

README.md

@@ -1,22 +1,16 @@
 # Welcome to Void.
 
+Void is the open-source Cursor alternative. This repo contains the full sourcecode for Void. We have a [waitlist](https://voideditor.com/email) for downloading the official release, but you can build and develop Void right now.
 
-Void is the open-source Cursor alternative. 
-
-If you're new, welcome! Feel free to check out our [Project board](https://github.com/orgs/voideditor/projects/2/views/3) for the most pressing Issues to work on, and see [`CONTRIBUTING.md`](https://github.com/voideditor/void/blob/main/CONTRIBUTING.md) for instructions on building and running Void.
-
-This repo contains the full sourcecode for Void. We have a [waitlist](https://voideditor.com/email) for downloading the official release, but you can build and develop Void right now.
+If you're new, welcome!
 
 ## Contributing
 
-To build and run Void, see [`CONTRIBUTING.md`](https://github.com/voideditor/void/blob/main/CONTRIBUTING.md).
+To build and run Void, follow the steps in [`CONTRIBUTING.md`](https://github.com/voideditor/void/blob/main/CONTRIBUTING.md).
 
 ## Reference
 
-Void is a fork of the of [vscode](https://github.com/microsoft/vscode) repository.
-
-For some useful links we've compiled see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).
-
+Void is a fork of the of [vscode](https://github.com/microsoft/vscode) repository. For some useful links on VSCode, see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).
 
 ## Support
-Feel free to reach out in our [Discord](https://discord.gg/PspNkKG5wt) or contact us via email.
+Feel free to reach out in our [Discord](https://discord.gg/RSNjgaugJs) or contact us via email.

VOID_USEFUL_LINKS.md

@@ -2,23 +2,27 @@
 
 The Void team put together this list of links to get up and running with VSCode's sourcecode. We hope it's helpful!
 
+## Contributing
+
+- [How VSCode's sourcecode is organized](https://github.com/microsoft/vscode/wiki/Source-Code-Organization) - this explains where the entry point files are, what `browser/` and `common/` mean, etc. This is the most important read on this whole list! We recommend reading the whole thing.
+
+- [Built-in VSCode styles](https://code.visualstudio.com/api/references/theme-color) - CSS variables that are built into VSCode. Use `var(--vscode-{theme but replacing . with -})`. You can also see their [Webview theming guide](https://code.visualstudio.com/api/extension-guides/webview#theming-webview-content).
+
 ## Beginners / Getting started
 
 - [VSCode UI guide](https://code.visualstudio.com/docs/getstarted/userinterface)  - covers auxbar, panels, etc.
 
 - [UX guide](https://code.visualstudio.com/api/ux-guidelines/overview) - covers Containers, Views, Items, etc.
 
-## Contributing
 
-- [How VS Code's sourcecode is organized](https://github.com/microsoft/vscode/wiki/Source-Code-Organization) - this explains where the entry point files are, what `browser/` and `common/` mean, etc. This is the most important read on this whole list! We recommend reading the whole thing.
+## Misc
 
-
-- [Every command](https://code.visualstudio.com/api/references/commands) built-in to VSCode - sometimes useful to reference.
+- [Every command](https://code.visualstudio.com/api/references/commands) built-in to VSCode - not used often, but here for reference.
 
 
 ## VSCode's Extension API
 
-Void is mainly an extension right now, and these links were very useful for us to get set up.
+Void is no longer an extension, so these links are no longer required, but they might be useful if we ever build an extension again.
 
 - [Files you need in an extension](https://code.visualstudio.com/api/get-started/extension-anatomy).
 

build/gulpfile.vscode.js

@@ -425,15 +425,15 @@ function packageTask(platform, arch, sourceFolderName, destinationFolderName, op
 				'resources/win32/vue.ico',
 				'resources/win32/xml.ico',
 				'resources/win32/yaml.ico',
-				'resources/win32/code_70x70.png',
-				'resources/win32/code_150x150.png'
+				'resources/win32/code_70x70.png', // <-- Void icon
+				'resources/win32/code_150x150.png' // <-- Void icon
 			], { base: '.' }));
 		} else if (platform === 'linux') {
-			all = es.merge(all, gulp.src('resources/linux/code.png', { base: '.' }));
+			all = es.merge(all, gulp.src('resources/linux/code.png', { base: '.' })); // <-- Void icon
 		} else if (platform === 'darwin') {
 			const shortcut = gulp.src('resources/darwin/bin/code.sh')
 				.pipe(replace('@@APPNAME@@', product.applicationName))
-				.pipe(rename('bin/code'));
+				.pipe(rename('bin/code')); // <-- Void icon
 
 			all = es.merge(all, shortcut);
 		}

build/lib/electron.js

@@ -54,7 +54,7 @@ function darwinBundleDocumentType(extensions, icon, nameOrSuffix, utis) {
         role: 'Editor',
         ostypes: ['TEXT', 'utxt', 'TUTX', '****'],
         extensions,
-        iconFile: 'resources/darwin/' + icon.toLowerCase() + '.icns',
+        iconFile: 'resources/darwin/' + icon.toLowerCase() + '.icns', // <-- Void icon code.icns
         utis
     };
 }
@@ -179,7 +179,7 @@ exports.config = {
     darwinForceDarkModeSupport: true,
     darwinCredits: darwinCreditsTemplate ? Buffer.from(darwinCreditsTemplate({ commit: commit, date: new Date().toISOString() })) : undefined,
     linuxExecutableName: product.applicationName,
-    winIcon: 'resources/win32/code.ico',
+    winIcon: 'resources/win32/code.ico', // <-- Void icon
     token: process.env['GITHUB_TOKEN'],
     repo: product.electronRepository || undefined,
     validateChecksum: true,

build/lib/electron.ts

@@ -68,7 +68,7 @@ function darwinBundleDocumentType(extensions: string[], icon: string, nameOrSuff
 		role: 'Editor',
 		ostypes: ['TEXT', 'utxt', 'TUTX', '****'],
 		extensions,
-		iconFile: 'resources/darwin/' + icon.toLowerCase() + '.icns',
+		iconFile: 'resources/darwin/' + icon.toLowerCase() + '.icns', // <-- Void icon code.icns
 		utis
 	};
 }
@@ -196,7 +196,7 @@ export const config = {
 	darwinForceDarkModeSupport: true,
 	darwinCredits: darwinCreditsTemplate ? Buffer.from(darwinCreditsTemplate({ commit: commit, date: new Date().toISOString() })) : undefined,
 	linuxExecutableName: product.applicationName,
-	winIcon: 'resources/win32/code.ico',
+	winIcon: 'resources/win32/code.ico', // <-- Void icon
 	token: process.env['GITHUB_TOKEN'],
 	repo: product.electronRepository || undefined,
 	validateChecksum: true,

build/npm/dirs.js

@@ -7,8 +7,6 @@ const fs = require('fs');
 
 // Complete list of directories where npm should be executed to install node modules
 const dirs = [
-	'extensions/void', // <-- Void
-
 	'',
 	'build',
 	'extensions',
@@ -55,6 +53,11 @@ const dirs = [
 	'test/smoke',
 	'.vscode/extensions/vscode-selfhost-import-aid',
 	'.vscode/extensions/vscode-selfhost-test-provider',
+
+	// Void added these:
+	// 'extensions/void',
+	// 'void-imports',
+
 ];
 
 if (fs.existsSync(`${__dirname}/../../.build/distro/npm`)) {

build/npm/postinstall.js

@@ -139,3 +139,21 @@ for (let dir of dirs) {
 
 cp.execSync('git config pull.rebase merges');
 cp.execSync('git config blame.ignoreRevsFile .git-blame-ignore-revs');
+
+
+// // Void added this (inject void-imports into project):
+// const buildVoidImports = () => {
+// 	console.log('\n\nVoid is injecting void-imports...')
+// 	cp.execSync(`npm install`, { // this goes here, not in postinstall, because we need to
+// 		env: process.env,
+// 		cwd: path.join(__dirname, '..', '..', '/void-imports'),
+// 		stdio: 'inherit'
+// 	});
+// 	cp.execSync(`node build-index.mjs`, {
+// 		env: process.env,
+// 		cwd: path.join(__dirname, '..', '..', '/void-imports'),
+// 		stdio: 'inherit'
+// 	});
+// 	console.log('Done injecting void-imports.')
+// }
+// buildVoidImports()

build/win32/code.iss

@@ -4,6 +4,7 @@
       ? ('; LicenseFile: "' + RepoDir + '\licenses\LICENSE-' + Language + '.rtf"') \
       : '; LicenseFile: "' + RepoDir + '\' + RootLicenseFileName + '"'
 
+
 [Setup]
 AppId={#AppId}
 AppName={#NameLong}
@@ -20,8 +21,10 @@ Compression=lzma
 SolidCompression=yes
 AppMutex={code:GetAppMutex}
 SetupMutex={#AppMutex}setup
-WizardImageFile="{#RepoDir}\resources\win32\inno-big-100.bmp,{#RepoDir}\resources\win32\inno-big-125.bmp,{#RepoDir}\resources\win32\inno-big-150.bmp,{#RepoDir}\resources\win32\inno-big-175.bmp,{#RepoDir}\resources\win32\inno-big-200.bmp,{#RepoDir}\resources\win32\inno-big-225.bmp,{#RepoDir}\resources\win32\inno-big-250.bmp"
-WizardSmallImageFile="{#RepoDir}\resources\win32\inno-small-100.bmp,{#RepoDir}\resources\win32\inno-small-125.bmp,{#RepoDir}\resources\win32\inno-small-150.bmp,{#RepoDir}\resources\win32\inno-small-175.bmp,{#RepoDir}\resources\win32\inno-small-200.bmp,{#RepoDir}\resources\win32\inno-small-225.bmp,{#RepoDir}\resources\win32\inno-small-250.bmp"
+; this is a Void icon comment. Old: WizardImageFile="{#RepoDir}\resources\win32\inno-big-100.bmp,{#RepoDir}\resources\win32\inno-big-125.bmp,{#RepoDir}\resources\win32\inno-big-150.bmp,{#RepoDir}\resources\win32\inno-big-175.bmp,{#RepoDir}\resources\win32\inno-big-200.bmp,{#RepoDir}\resources\win32\inno-big-225.bmp,{#RepoDir}\resources\win32\inno-big-250.bmp"
+; this is a Void icon comment. Old: WizardSmallImageFile="{#RepoDir}\resources\win32\inno-small-100.bmp,{#RepoDir}\resources\win32\inno-small-125.bmp,{#RepoDir}\resources\win32\inno-small-150.bmp,{#RepoDir}\resources\win32\inno-small-175.bmp,{#RepoDir}\resources\win32\inno-small-200.bmp,{#RepoDir}\resources\win32\inno-small-225.bmp,{#RepoDir}\resources\win32\inno-small-250.bmp"
+WizardImageFile="{#RepoDir}\resources\win32\inno-void.bmp"
+WizardSmallImageFile="{#RepoDir}\resources\win32\inno-void.bmp"
 SetupIconFile={#RepoDir}\resources\win32\code.ico
 UninstallDisplayIcon={app}\{#ExeBasename}.exe
 ChangesEnvironment=true

extensions/void/.eslintrc

@@ -1,56 +0,0 @@
-{
-	"root": true,
-	"parser": "@typescript-eslint/parser",
-	"parserOptions": {
-		"ecmaVersion": 6,
-		"sourceType": "module",
-		"ecmaFeatures": {
-			"jsx": true
-		}
-	},
-	"plugins": [
-		"@typescript-eslint",
-		"react",
-		"react-hooks"
-	],
-	"extends": [
-		"eslint:recommended",
-		"plugin:react/recommended",
-		"plugin:react-hooks/recommended"
-	],
-	"rules": {
-		"@typescript-eslint/naming-convention": [
-			"warn",
-			{
-				"selector": "import",
-				"format": [
-					"camelCase",
-					"PascalCase"
-				]
-			}
-		],
-		"curly": "off",
-		"eqeqeq": "warn",
-		"no-empty": "off",
-		"no-throw-literal": "warn",
-		"semi": "off",
-		"no-unused-vars": "off",
-		"react-hooks/exhaustive-deps": "warn"
-	},
-	"ignorePatterns": [
-		"out",
-		"dist",
-		"**/*.d.ts"
-	],
-	"settings": {
-		"react": {
-			"version": "detect"
-		}
-	},
-	"env": {
-		"browser": true, // enable browser globals linting (window, document, console, etc)
-		"es6": true, // enable ES6 linting
-		"node": true, // enable Node linting (things like Buffer which is used in file reading, etc)
-		"mocha": true // enable Mocha linting
-	}
-}

extensions/void/.gitignore

@@ -1,5 +0,0 @@
-out
-dist
-node_modules
-.vscode-test/
-*.vsix

extensions/void/.vscode-test.mjs

@@ -1,5 +0,0 @@
-import { defineConfig } from '@vscode/test-cli';
-
-export default defineConfig({
-	files: 'out/test/**/*.test.js',
-});

extensions/void/.vscode/extensions.json

@@ -1,8 +0,0 @@
-{
-	// See http://go.microsoft.com/fwlink/?LinkId=827846
-	// for the documentation about the extensions.json format
-	"recommendations": [
-		"dbaeumer.vscode-eslint",
-		"ms-vscode.extension-test-runner"
-	]
-}

extensions/void/.vscode/launch.json

@@ -1,21 +0,0 @@
-// A launch configuration that compiles the extension and then opens it inside a new window
-// Use IntelliSense to learn about possible attributes.
-// Hover to view descriptions of existing attributes.
-// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-{
-	"version": "0.2.0",
-	"configurations": [
-		{
-			"name": "Run Extension",
-			"type": "extensionHost",
-			"request": "launch",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}"
-			],
-			"outFiles": [
-				"${workspaceFolder}/out/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}"
-		}
-	]
-}

extensions/void/.vscode/settings.json

@@ -1,18 +0,0 @@
-// Place your settings in this file to overwrite default and user settings.
-{
-	"files.exclude": {
-		"**/.git": true,
-		"**/.svn": true,
-		"**/.hg": true,
-		"**/CVS": true,
-		"**/.DS_Store": true,
-		"**/Thumbs.db": true,
-		"out": false,
-		"**/node_modules": true
-	},
-	"search.exclude": {
-		"out": true // set this to false to include "out" folder in search results
-	},
-	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off",
-}

extensions/void/.vscode/tasks.json

@@ -1,20 +0,0 @@
-// See https://go.microsoft.com/fwlink/?LinkId=733558
-// for the documentation about the tasks.json format
-{
-	"version": "2.0.0",
-	"tasks": [
-		{
-			"type": "npm",
-			"script": "watch",
-			"problemMatcher": "$tsc-watch",
-			"isBackground": true,
-			"presentation": {
-				"reveal": "never"
-			},
-			"group": {
-				"kind": "build",
-				"isDefault": true
-			}
-		}
-	]
-}

extensions/void/.vscodeignore

@@ -1,11 +0,0 @@
-.vscode/**
-.vscode-test/**
-src/**
-.gitignore
-.yarnrc
-vsc-extension-quickstart.md
-**/tsconfig.json
-**/.eslintrc.json
-**/*.map
-**/*.ts
-**/.vscode-test.*

extensions/void/LangaugeServerTest/createJsProgramGraph.ts

@@ -0,0 +1,333 @@
+import * as vscode from 'vscode';
+import Parser from 'tree-sitter';
+import JavaScript from 'tree-sitter-javascript';
+
+interface Definition {
+    file: string;
+    node: Parser.SyntaxNode;
+}
+
+interface DefnUse {
+    parent: Parser.SyntaxNode;
+    file: string;
+}
+
+interface ImportInfo {
+    source: string;
+    imported: string;
+}
+
+class ProjectAnalyzer {
+    private parser: Parser;
+    private graph: Map<string, Set<string>>;
+    private visited: Set<string>;
+    private parsedFiles: Map<string, Parser.Tree>;
+    private imports: Map<string, Map<string, ImportInfo>>;
+    private definitions: Map<string, Definition>;
+    private fileStack: Set<string>;
+
+    constructor() {
+        this.parser = new Parser();
+        this.parser.setLanguage(JavaScript);
+        this.graph = new Map();
+        this.visited = new Set();
+        this.parsedFiles = new Map();
+        this.imports = new Map();
+        this.definitions = new Map();
+        this.fileStack = new Set();
+    }
+
+    async parseFile(filePath: string): Promise<Parser.Tree | null> {
+        if (this.parsedFiles.has(filePath)) {
+            return this.parsedFiles.get(filePath)!;
+        }
+
+        if (this.fileStack.has(filePath)) {
+            return null; // Circular import
+        }
+
+        this.fileStack.add(filePath);
+
+        try {
+            const uri = vscode.Uri.file(filePath);
+            const document = await vscode.workspace.openTextDocument(uri);
+            const code = document.getText();
+            const tree = this.parser.parse(code);
+
+            this.parsedFiles.set(filePath, tree);
+            this.collectImports(filePath, tree);
+            this.collectDefinitions(filePath, tree);
+
+            return tree;
+        } catch (error) {
+            console.error(`Error parsing ${filePath}:`, error);
+            return null;
+        } finally {
+            this.fileStack.delete(filePath);
+        }
+    }
+
+    private collectImports(filePath: string, tree: Parser.Tree): void {
+        const fileImports = new Map<string, ImportInfo>();
+
+        const visit = (node: Parser.SyntaxNode): void => {
+            if (node.type === 'import_declaration') {
+                const source = node.childForFieldName('source')?.text.slice(1, -1) ?? '';
+                const specifiers = node.childForFieldName('specifiers');
+
+                specifiers?.children.forEach(spec => {
+                    if (spec.type === 'import_specifier') {
+                        const local = spec.childForFieldName('local')?.text ?? '';
+                        const imported = spec.childForFieldName('imported')?.text ?? '';
+                        fileImports.set(local, { source, imported });
+                    }
+                });
+            }
+            node.children.forEach(visit);
+        };
+
+        visit(tree.rootNode);
+        this.imports.set(filePath, fileImports);
+    }
+
+    private collectDefinitions(filePath: string, tree: Parser.Tree): void {
+        const visit = (node: Parser.SyntaxNode): void => {
+            if (node.type === 'function_declaration') {
+                const name = node.childForFieldName('name')?.text ?? '';
+                this.definitions.set(name, { file: filePath, node });
+            }
+            else if (node.type === 'variable_declarator') {
+                const name = node.childForFieldName('name')?.text;
+                const value = node.childForFieldName('value');
+                if (name && (value?.type === 'arrow_function' || value?.type === 'function')) {
+                    this.definitions.set(name, { file: filePath, node: value });
+                }
+            }
+            node.children.forEach(visit);
+        };
+
+        visit(tree.rootNode);
+    }
+
+    private async getTypeFromPosition(uri: vscode.Uri, position: vscode.Position): Promise<string | null> {
+        const hover = await vscode.commands.executeCommand<vscode.Hover[]>(
+            'vscode.executeHoverProvider',
+            uri,
+            position
+        );
+
+        if (hover?.[0]?.contents.length) {
+            for (const content of hover[0].contents) {
+                let hoverText = typeof content === 'string' ?
+                    content :
+                    ('value' in content ? content.value : '');
+
+                // Remove typescript backticks if present
+                hoverText = hoverText.replace(/```typescript\s*/, '').replace(/```\s*$/, '');
+                console.log('Processing hover text:', hoverText);
+
+                // Extract the type information - look for the type after the colon
+                const typeMatches = [
+                    /:\s*([\w<>]+)(?:\[\])?/,  // matches "foo: Type" or "foo: Type[]"
+                    /var\s+\w+:\s*([\w<>]+)/,  // matches "var foo: Type"
+                    /\(type\)\s+[\w<>]+:\s*([\w<>]+)/,  // matches "(type) foo: Type"
+                    /\(method\)\s*([\w<>]+)\./  // matches "(method) Type.method"
+                ];
+
+                for (const pattern of typeMatches) {
+                    const match = pattern.exec(hoverText);
+                    if (match) {
+                        let type = match[1];
+                        // Handle array types
+                        if (hoverText.includes('[]')) {
+                            return 'Array';
+                        }
+                        // Extract base type from generics
+                        if (type.includes('<')) {
+                            type = type.split('<')[0];
+                        }
+                        return type;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private async getCallsInDefn(defnNode: Parser.SyntaxNode, currentFile: string): Promise<Set<string>> {
+        const calls = new Set<string>();
+        const fileImports = this.imports.get(currentFile) ?? new Map();
+        const uri = vscode.Uri.file(currentFile);
+
+        const visit = async (node: Parser.SyntaxNode): Promise<void> => {
+            if (node.type === 'call_expression') {
+                const callee = node.childForFieldName('function');
+                if (callee?.type === 'identifier') {
+                    const name = callee.text;
+                    const importInfo = fileImports.get(name);
+                    if (importInfo) {
+                        calls.add(`${importInfo.source}:${importInfo.imported}`);
+                    } else {
+                        calls.add(name);
+                    }
+                }
+                else if (callee?.type === 'member_expression') {
+                    const method = callee.childForFieldName('property')?.text;
+                    const object = callee.childForFieldName('object');
+
+                    if (method && object) {
+                        const position = new vscode.Position(
+                            object.startPosition.row,
+                            object.startPosition.column
+                        );
+
+                        const type = await this.getTypeFromPosition(uri, position);
+                        if (type) {
+                            calls.add(`${type}.${method}`);
+                        } else {
+                            calls.add(`method:${method}`);
+                        }
+                    }
+                }
+            }
+
+            for (const child of node.children) {
+                await visit(child);
+            }
+        };
+
+        await visit(defnNode);
+        return calls;
+    }
+
+    private gotoDefn(name: string): Definition | null {
+        if (name.includes(':')) {
+            const [file, funcName] = name.split(':');
+            const def = this.definitions.get(funcName);
+            return def ?? null;
+        }
+
+        return this.definitions.get(name) ?? null;
+    }
+
+    private getUses(defnNode: Parser.SyntaxNode, currentFile: string): DefnUse[] {
+        const uses: DefnUse[] = [];
+
+        let fnName: string | undefined;
+        if (defnNode.type === 'function_declaration') {
+            fnName = defnNode.childForFieldName('name')?.text;
+        } else if (defnNode.type === 'arrow_function' || defnNode.type === 'function') {
+            const parent = defnNode.parent;
+            if (parent?.type === 'variable_declarator') {
+                fnName = parent.childForFieldName('name')?.text;
+            }
+        }
+
+        if (!fnName) return uses;
+
+        for (const [file, tree] of this.parsedFiles) {
+            const visit = (node: Parser.SyntaxNode): void => {
+                if (node.type === 'call_expression') {
+                    const callee = node.childForFieldName('function');
+                    if (callee?.type === 'identifier' && callee.text === fnName) {
+                        let current: Parser.SyntaxNode | null = node;
+                        while (current) {
+                            if (current.type === 'function_declaration' ||
+                                current.type === 'arrow_function' ||
+                                current.type === 'function') {
+                                uses.push({ parent: current, file });
+                                break;
+                            }
+                            current = current.parent;
+                        }
+                    }
+                }
+                node.children.forEach(visit);
+            };
+
+            visit(tree.rootNode);
+        }
+
+        return uses;
+    }
+
+    private async visitAllNodesInGraphFromDefinition(defn: Parser.SyntaxNode, currentFile: string): Promise<void> {
+        let defnName: string | undefined;
+        if (defn.type === 'function_declaration') {
+            defnName = defn.childForFieldName('name')?.text;
+        } else if (defn.type === 'arrow_function' || defn.type === 'function') {
+            const parent = defn.parent;
+            if (parent?.type === 'variable_declarator') {
+                defnName = parent.childForFieldName('name')?.text;
+            }
+        }
+
+        if (!defnName) return;
+
+        const fullName = `${currentFile}:${defnName}`;
+        if (this.visited.has(fullName)) return;
+
+        const calls = await this.getCallsInDefn(defn, currentFile);
+        this.graph.set(fullName, calls);
+        this.visited.add(fullName);
+
+        const callDefns = Array.from(calls).map(call => this.gotoDefn(call));
+        for (const callDefn of callDefns) {
+            if (callDefn) {
+                await this.visitAllNodesInGraphFromDefinition(callDefn.node, callDefn.file);
+            }
+        }
+
+        const defnUses = this.getUses(defn, currentFile);
+        for (const defnUse of defnUses) {
+            await this.visitAllNodesInGraphFromDefinition(defnUse.parent, defnUse.file);
+        }
+    }
+
+    async analyze(entryFile: string): Promise<Map<string, Set<string>>> {
+        const tree = await this.parseFile(entryFile);
+        if (!tree) return new Map();
+
+        const visit = async (node: Parser.SyntaxNode): Promise<void> => {
+            if (node.type === 'function_declaration') {
+                await this.visitAllNodesInGraphFromDefinition(node, entryFile);
+            }
+            else if (node.type === 'variable_declarator') {
+                const value = node.childForFieldName('value');
+                if (value?.type === 'arrow_function' || value?.type === 'function') {
+                    await this.visitAllNodesInGraphFromDefinition(value, entryFile);
+                }
+            }
+            for (const child of node.children) {
+                await visit(child);
+            }
+        };
+
+        await visit(tree.rootNode);
+        return this.graph;
+    }
+}
+
+export async function runTreeSitter(filePath?: string): Promise<Map<string, Set<string>> | null> {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor && !filePath) {
+        vscode.window.showWarningMessage('No active editor found');
+        return null;
+    }
+
+    try {
+        const targetPath = filePath ?? editor!.document.uri.fsPath;
+        const analyzer = new ProjectAnalyzer();
+        const graph = await analyzer.analyze(targetPath);
+
+        for (const [defn, calls] of graph) {
+            console.log(`${defn} calls: ${[...calls].join(', ')}`);
+        }
+
+        return graph;
+    } catch (error) {
+        console.error('Error analyzing file:', error);
+        vscode.window.showErrorMessage('Error analyzing file');
+        return null;
+    }
+}

extensions/void/LangaugeServerTest/findFunctions.ts

@@ -0,0 +1,62 @@
+import * as vscode from 'vscode';
+
+const legend = new vscode.SemanticTokensLegend([], []);
+
+export async function findFunctions() {
+
+	const editor = vscode.window.activeTextEditor;
+	if (!editor) return;
+	const document = editor.document;
+
+	const tokens = await vscode.commands.executeCommand<vscode.SemanticTokens>(
+		'vscode.provideDocumentSemanticTokens',
+		document.uri
+	);
+
+	if (!tokens) {
+		console.error('No tokens found');
+		return [];
+	}
+
+	const allTokens = decodeTokens(tokens, document);
+
+
+	return allTokens;
+}
+
+function decodeTokens(tokens: vscode.SemanticTokens, document: vscode.TextDocument) {
+	const data = tokens.data;
+	const decodedTokens = [];
+	let line = 0;
+	let character = 0;
+
+	for (let i = 0; i < data.length; i += 5) {
+		const deltaLine = data[i];
+		const deltaStartChar = data[i + 1];
+		const length = data[i + 2];
+		const tokenTypeIdx = data[i + 3];
+		const tokenModifierIdx = data[i + 4];
+
+		line += deltaLine;
+		character = deltaLine === 0 ? character + deltaStartChar : deltaStartChar;
+
+		const type = legend.tokenTypes[tokenTypeIdx] || `(${tokenTypeIdx})`;
+		const modifier = legend.tokenModifiers[tokenModifierIdx] || `(${tokenModifierIdx})`;
+
+		const tokenRange = new vscode.Range(line, character, line, character + length);
+		const tokenText = document.getText(tokenRange);
+
+		decodedTokens.push({
+			line,
+			startCharacter: character,
+			length,
+			type,
+			modifier,
+			text: tokenText,
+		});
+
+		console.log(`Token: '${tokenText}' | Type: ${type} | Modifier: ${modifier} | Line: ${line}, Character: ${character}`);
+	}
+
+	return decodedTokens;
+}

extensions/void/README.md

@@ -1,11 +0,0 @@
-Please see the `CONTRIBUTING.md` for information on how to contribute :)!
-
-
-Here's an overview on how the extension works:
-
-- The extension mounts in `extension.ts`.
-
-- The Sidebar's HTML (everything in `sidebar/`) is built in React, and it's rendered by mounting a `<script>` tag - see `SidebarWebviewProvider.ts`.
-
-- Communication between the sidebar script and the extension takes place via API. You can search for "postMessage" to see where API calls happen.
-

extensions/void/README.txt

@@ -0,0 +1,3 @@
+This folder is no longer relevant, since Void is no longer just an extension.
+
+See the new Void code in `src/vs/workbench/contrib/void` (and a few other locations - you can just search "Void").

extensions/void/build-css.js

@@ -1,19 +0,0 @@
-const tailwindcss = require('tailwindcss')
-const autoprefixer = require('autoprefixer')
-const postcss = require('postcss')
-const fs = require('fs')
-
-const from = 'src/sidebar/styles.css'
-const to = 'dist/sidebar/styles.css'
-
-const original_css_contents = fs.readFileSync(from, 'utf8')
-
-postcss([
-    tailwindcss, // this compiles tailwind of all the files specified in tailwind.config.json
-    autoprefixer,
-])
-    .process(original_css_contents, { from, to })
-    .then(processed_css_contents => { fs.writeFileSync(to, processed_css_contents.css) })
-    .catch(error => {
-        console.error('Error in build-css:', error)
-    })

extensions/void/build-tsx.js

@@ -1,13 +0,0 @@
-const esbuild = require('esbuild')
-
-// Build JS
-esbuild.build({
-  entryPoints: ['src/sidebar/index.tsx'],
-  bundle: true,
-  minify: true,
-  sourcemap: true,
-  outfile: 'dist/sidebar/index.js',
-  format: 'iife', // apparently iife is safe for browsers (safer than cjs)
-  platform: 'browser',
-  external: ['vscode'],
-}).catch(() => process.exit(1));

extensions/void/package.json

@@ -1,148 +0,0 @@
-{
-  "name": "void",
-  "publisher": "void",
-  "displayName": "Void",
-  "description": "",
-  "version": "0.0.1",
-  "engines": {
-    "vscode": "^1.89.0"
-  },
-  "categories": [
-    "Other"
-  ],
-  "activationEvents": [],
-  "main": "./out/extension.js",
-  "contributes": {
-    "configuration": {
-      "title": "Void",
-      "properties": {}
-    },
-    "commands": [
-      {
-        "command": "void.ctrl+l",
-        "title": "Show Sidebar"
-      },
-      {
-        "command": "void.ctrl+k",
-        "title": "Show Selection Lens"
-      },
-      {
-        "command": "void.acceptDiff",
-        "title": "Approve Diff"
-      },
-      {
-        "command": "void.rejectDiff",
-        "title": "Discard Diff"
-      },
-      {
-        "command": "void.startNewThread",
-        "title": "Start a new chat",
-        "icon": "$(add)"
-      },
-      {
-        "command": "void.toggleThreadSelector",
-        "title": "View past chats",
-        "icon": "$(history)"
-      },
-      {
-        "command": "void.toggleSettings",
-        "title": "Void settings",
-        "icon": "$(settings-gear)"
-      }
-    ],
-    "viewsContainers": {
-      "activitybar": [
-        {
-          "id": "voidViewContainer",
-          "title": "Chat",
-          "icon": "$(hubot)"
-        }
-      ]
-    },
-    "views": {
-      "voidViewContainer": [
-        {
-          "type": "webview",
-          "id": "void.viewnumberone",
-          "name": "Void"
-        }
-      ]
-    },
-    "keybindings": [
-      {
-        "command": "void.ctrl+l",
-        "key": "ctrl+l",
-        "mac": "cmd+l"
-      },
-      {
-        "command": "void.ctrl+k",
-        "key": "ctrl+k",
-        "mac": "cmd+k"
-      }
-    ],
-    "menus": {
-      "view/title": [
-        {
-          "command": "void.startNewThread",
-          "when": "view == 'void.viewnumberone'",
-          "group": "navigation"
-        },
-        {
-          "command": "void.toggleThreadSelector",
-          "when": "view == 'void.viewnumberone'",
-          "group": "navigation"
-        },
-        {
-          "command": "void.toggleSettings",
-          "when": "view == 'void.viewnumberone'",
-          "group": "navigation"
-        }
-      ]
-    }
-  },
-  "scripts": {
-    "vscode:prepublish": "npm run compile",
-    "watch": "tsc -watch -p ./",
-    "build": "rimraf dist && node build-tsx.js && node build-css.js",
-    "pretest": "tsc -p ./ && eslint src --ext ts",
-    "test": "vscode-test"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.9.1",
-    "@types/diff": "^5.2.2",
-    "@types/diff-match-patch": "^1.0.36",
-    "@types/jest": "^29.5.12",
-    "@types/mocha": "^10.0.8",
-    "@types/node": "^22.5.1",
-    "@types/react": "^18.3.4",
-    "@types/react-dom": "^18.3.0",
-    "@types/vscode": "1.92.0",
-    "@typescript-eslint/eslint-plugin": "^8.3.0",
-    "@typescript-eslint/parser": "^8.3.0",
-    "@vscode/test-cli": "^0.0.10",
-    "@vscode/test-electron": "2.4.1",
-    "autoprefixer": "^10.4.20",
-    "diff-match-patch": "^1.0.5",
-    "esbuild": "^0.23.1",
-    "eslint": "^8.57.0",
-    "eslint-plugin-react": "^7.35.1",
-    "eslint-plugin-react-hooks": "^4.6.2",
-    "globals": "^15.9.0",
-    "marked": "^14.1.0",
-    "ollama": "^0.5.9",
-    "postcss": "^8.4.41",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-markdown": "^9.0.1",
-    "react-syntax-highlighter": "^15.6.1",
-    "rimraf": "^6.0.1",
-    "tailwindcss": "^3.4.10",
-    "typescript": "5.5.4",
-    "typescript-eslint": "^8.3.0",
-    "uuid": "^10.0.0"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.27.1",
-    "openai": "^4.57.0"
-  }
-}

extensions/void/src/DisplayChangesProvider.ts

@@ -1,315 +0,0 @@
-import * as vscode from 'vscode';
-import { findDiffs } from './findDiffs';
-import { Diff, BaseDiffArea, BaseDiff, DiffArea } from './shared_types';
-
-
-
-// TODO in theory this should be disposed
-const greenDecoration = vscode.window.createTextEditorDecorationType({
-	backgroundColor: 'rgba(0 255 51 / 0.2)',
-	isWholeLine: false, // after: { contentText: '       [original]', color: 'rgba(0 255 60 / 0.5)' }  // hoverMessage: originalText // this applies to hovering over after:...
-})
-
-
-// responsible for displaying diffs and showing accept/reject buttons
-export class DisplayChangesProvider implements vscode.CodeLensProvider {
-
-	private _diffAreasOfDocument: { [docUriStr: string]: DiffArea[] } = {}
-	private _diffsOfDocument: { [docUriStr: string]: Diff[] } = {}
-
-	private _diffareaidPool = 0
-	private _diffidPool = 0
-	private _weAreEditing: boolean = false
-
-	// used internally by vscode
-	private _onDidChangeCodeLenses: vscode.EventEmitter<void> = new vscode.EventEmitter<void>(); // signals a UI refresh on .fire() events
-	public readonly onDidChangeCodeLenses: vscode.Event<void> = this._onDidChangeCodeLenses.event;
-
-	// used internally by vscode
-	public provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.CodeLens[]> {
-		const docUriStr = document.uri.toString()
-		return this._diffsOfDocument[docUriStr]?.flatMap(diff => diff.lenses) ?? []
-	}
-
-	// declared by us, registered with vscode.languages.registerCodeLensProvider()
-	constructor() {
-
-		console.log('Creating DisplayChangesProvider')
-
-		// this acts as a useEffect. Every time text changes, clear the diffs in this editor
-		vscode.workspace.onDidChangeTextDocument((e) => {
-
-			const editor = vscode.window.activeTextEditor
-
-			if (!editor)
-				return
-			if (this._weAreEditing)
-				return
-
-			const docUri = editor.document.uri
-			const docUriStr = docUri.toString()
-			const diffAreas = this._diffAreasOfDocument[docUriStr] || []
-
-			// loop through each change
-			for (const change of e.contentChanges) {
-
-				// here, `change.range` is the range of the original file that gets replaced with `change.text`
-
-
-				// compute net number of newlines lines that were added/removed
-				const numNewLines = (change.text.match(/\n/g) || []).length
-				const numLineDeletions = change.range.end.line - change.range.start.line
-				const deltaNewlines = numNewLines - numLineDeletions
-
-				// compute overlap with each diffArea and shrink/elongate the diffArea accordingly
-				for (const diffArea of diffAreas) {
-
-					// if the change is fully within the diffArea, elongate it by the delta amount of newlines
-					if (change.range.start.line >= diffArea.startLine && change.range.end.line <= diffArea.endLine) {
-						diffArea.endLine += deltaNewlines
-					}
-					// check if the `diffArea` was fully deleted and remove it if so
-					if (diffArea.startLine > diffArea.endLine) {
-						//remove it
-						const index = diffAreas.findIndex(da => da === diffArea)
-						diffAreas.splice(index, 1)
-					}
-
-					// TODO handle other cases where eg. the change overlaps many diffAreas
-				}
-
-
-				// if a diffArea is below the last character of the change, shift the diffArea up/down by the delta amount of newlines
-				for (const diffArea of diffAreas) {
-					if (diffArea.startLine > change.range.end.line) {
-						diffArea.startLine += deltaNewlines
-						diffArea.endLine += deltaNewlines
-					}
-				}
-
-				// TODO merge any diffAreas if they overlap with each other as a result from the shift
-
-			}
-
-			// refresh the diffAreas
-			this.refreshDiffAreas(docUri)
-
-		})
-	}
-
-
-	// used by us only
-	public addDiffArea(uri: vscode.Uri, diffArea: BaseDiffArea) {
-
-		const uriStr = uri.toString()
-
-		// make sure array is defined
-		if (!this._diffAreasOfDocument[uriStr])
-			this._diffAreasOfDocument[uriStr] = []
-
-		// remove all diffAreas that the new `diffArea` is overlapping with
-		this._diffAreasOfDocument[uriStr] = this._diffAreasOfDocument[uriStr].filter(da => {
-
-			const noOverlap = da.startLine > diffArea.endLine || da.endLine < diffArea.startLine
-
-			if (!noOverlap) return false
-
-			return true
-		})
-
-		// add `diffArea` to storage
-		this._diffAreasOfDocument[uriStr].push({
-			...diffArea,
-			diffareaid: this._diffareaidPool
-		})
-		this._diffareaidPool += 1
-	}
-
-
-	// used by us only
-	public refreshDiffAreas(docUri: vscode.Uri) {
-
-		const editor = vscode.window.activeTextEditor // TODO the editor should be that of `docUri` and not necessarily the current editor
-		if (!editor) {
-			console.log('Error: No active editor!')
-			return;
-		}
-
-		const docUriStr = docUri.toString()
-		const diffAreas = this._diffAreasOfDocument[docUriStr] || []
-
-		// reset all diffs (we update them below)
-		this._diffsOfDocument[docUriStr] = []
-
-		// for each diffArea
-		for (const diffArea of diffAreas) {
-
-			// get code inside of diffArea
-			const currentCode = editor.document.getText(new vscode.Range(diffArea.startLine, 0, diffArea.endLine, Number.MAX_SAFE_INTEGER)).replace(/\r\n/g, '\n')
-
-			// compute the diffs
-			const diffs = findDiffs(diffArea.originalCode, currentCode)
-
-			// print diffs
-			console.log('!CODEBefore:', JSON.stringify(diffArea.originalCode))
-			console.log('!CODEAfter:', JSON.stringify(currentCode))
-
-			// add the diffs to `this._diffsOfDocument[docUriStr]`
-			this.addDiffs(editor.document.uri, diffs, diffArea)
-
-			for (const diff of this._diffsOfDocument[docUriStr]) {
-				console.log('------------')
-				console.log('deletedCode:', JSON.stringify(diff.deletedCode))
-				console.log('insertedCode:', JSON.stringify(diff.insertedCode))
-				console.log('deletedRange:', diff.deletedRange.start.line, diff.deletedRange.end.line,)
-				console.log('insertedRange:', diff.insertedRange.start.line, diff.insertedRange.end.line,)
-			}
-
-
-		}
-
-		// update green highlighting
-		editor.setDecorations(
-			greenDecoration,
-			(this._diffsOfDocument[docUriStr]
-				.filter(diff => diff.insertedRange !== undefined)
-				.map(diff => diff.insertedRange)
-			)
-		);
-
-		// TODO update red highlighting
-		// this._diffsOfDocument[docUriStr].map(diff => diff.deletedCode)
-
-		// update code lenses
-		this._onDidChangeCodeLenses.fire()
-
-	}
-
-	// used by us only
-	public addDiffs(docUri: vscode.Uri, diffs: BaseDiff[], diffArea: DiffArea) {
-
-		const docUriStr = docUri.toString()
-
-		// if no diffs, set diffs to []
-		if (!this._diffsOfDocument[docUriStr])
-			this._diffsOfDocument[docUriStr] = []
-
-		// add each diff and its codelens to the document
-		for (let i = diffs.length - 1; i > -1; i -= 1) {
-			let suggestedDiff = diffs[i]
-
-			this._diffsOfDocument[docUriStr].push({
-				...suggestedDiff,
-				diffid: this._diffidPool,
-				// originalCode: suggestedDiff.deletedText,
-				lenses: [
-					new vscode.CodeLens(suggestedDiff.insertedRange, { title: 'Accept', command: 'void.acceptDiff', arguments: [{ diffid: this._diffidPool, diffareaid: diffArea.diffareaid }] }),
-					new vscode.CodeLens(suggestedDiff.insertedRange, { title: 'Reject', command: 'void.rejectDiff', arguments: [{ diffid: this._diffidPool, diffareaid: diffArea.diffareaid }] })
-				]
-			});
-			this._diffidPool += 1
-		}
-
-	}
-
-	// called on void.acceptDiff
-	public async acceptDiff({ diffid, diffareaid }: { diffid: number, diffareaid: number }) {
-		const editor = vscode.window.activeTextEditor
-		if (!editor)
-			return
-
-		// get document uri
-		const docUri = editor.document.uri
-		const docUriStr = docUri.toString()
-
-		// get relevant diff
-		// TODO speed up with hashmap
-		const diffIdx = this._diffsOfDocument[docUriStr].findIndex(diff => diff.diffid === diffid);
-		if (diffIdx === -1) {
-			console.error('Error: DiffID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return;
-		}
-
-		// get relevant diffArea
-		const diffareaIdx = this._diffAreasOfDocument[docUriStr].findIndex(diff => diff.diffareaid === diffareaid);
-		if (diffareaIdx === -1) {
-			console.error('Error: DiffAreaID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return;
-		}
-
-		const diff = this._diffsOfDocument[docUriStr][diffIdx]
-		const diffArea = this._diffAreasOfDocument[docUriStr][diffareaIdx]
-
-		// replace `originalCode[diff.deletedRange]` with diff.insertedCode
-		// TODO add a history event to undo this change
-		const originalLines = diffArea.originalCode.split('\n');
-		const relativeStart = diff.deletedRange.start.line - diffArea.originalStartLine
-		const relativeEnd = diff.deletedRange.end.line - diffArea.originalStartLine
-		diffArea.originalCode = [
-			...originalLines.slice(0, relativeStart),	// lines before the deleted range
-			...diff.insertedCode.split('\n'),			// inserted lines
-			...originalLines.slice(relativeEnd + 1)		// lines after the deleted range
-		].join('\n')
-
-		// if the diffArea has no changes, remove it
-		const currentDiffAreaCode = editor.document.getText()
-			.replace(/\r\n/g, '\n')
-			.split('\n')
-			.slice(diffArea.startLine, diffArea.endLine + 1)
-			.join('\n')
-		if (diffArea.originalCode === currentDiffAreaCode) { // if the currentDiffAreaCode === diffArea.originalCode, remove the diffArea
-			const index = this._diffAreasOfDocument[docUriStr].findIndex(da => da.diffareaid === diffArea.diffareaid)
-			this._diffAreasOfDocument[docUriStr].splice(index, 1)
-		}
-
-		// refresh the diff area
-		this.refreshDiffAreas(docUri)
-	}
-
-
-	// called on void.rejectDiff
-	public async rejectDiff({ diffid, diffareaid }: { diffid: number, diffareaid: number }) {
-		const editor = vscode.window.activeTextEditor
-		if (!editor)
-			return
-
-		// get document uri
-		const docUri = editor.document.uri
-		const docUriStr = docUri.toString()
-
-		// get relevant diff
-		// TODO speed up with hashmap
-		const diffIdx = this._diffsOfDocument[docUriStr].findIndex(diff => diff.diffid === diffid);
-		if (diffIdx === -1) {
-			console.error('Error: DiffID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return;
-		}
-
-		// get relevant diffArea
-		const diffareaIdx = this._diffAreasOfDocument[docUriStr].findIndex(diff => diff.diffareaid === diffareaid);
-		if (diffareaIdx === -1) {
-			console.error('Error: DiffAreaID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return;
-		}
-
-		const diff = this._diffsOfDocument[docUriStr][diffIdx]
-		const diffArea = this._diffAreasOfDocument[docUriStr][diffareaIdx]
-
-		// replace `editorCode[diff.insertedRange]` with diff.deletedCode
-		const workspaceEdit = new vscode.WorkspaceEdit();
-		workspaceEdit.replace(docUri, diff.insertedRange, diff.deletedCode)
-		this._weAreEditing = true
-		await vscode.workspace.applyEdit(workspaceEdit)
-		this._weAreEditing = false
-
-		// if the diffArea has no changes, remove it
-		const currentDiffAreaCode = editor.document.getText()
-			.replace(/\r\n/g, '\n')
-			.split('\n')
-			.slice(diffArea.startLine, diffArea.endLine + 1)
-			.join('\n')
-		if (diffArea.originalCode === currentDiffAreaCode) { // if the currentDiffAreaCode === diffArea.originalCode, remove the diffArea
-			const index = this._diffAreasOfDocument[docUriStr].findIndex(da => da.diffareaid === diffArea.diffareaid)
-			this._diffAreasOfDocument[docUriStr].splice(index, 1)
-		}
-
-		// refresh the diff area
-		this.refreshDiffAreas(docUri)
-	}
-}

extensions/void/src/SidebarWebviewProvider.ts

@@ -1,84 +0,0 @@
-// renders the code from `src/sidebar`
-
-import * as vscode from 'vscode';
-
-function getNonce() {
-	let text = "";
-	const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-	for (let i = 0; i < 32; i++) {
-		text += possible.charAt(Math.floor(Math.random() * possible.length));
-	}
-	return text;
-}
-
-export class SidebarWebviewProvider implements vscode.WebviewViewProvider {
-	public static readonly viewId = 'void.viewnumberone';
-
-	public webview: Promise<vscode.Webview> // used to send messages to the webview, resolved by _res in resolveWebviewView
-	private _res: (c: vscode.Webview) => void // used to resolve the webview
-
-	private readonly _extensionUri: vscode.Uri
-
-	// private _webviewView?: vscode.WebviewView;
-	private _webviewDeps: string[] = [];
-
-	constructor(context: vscode.ExtensionContext) {
-		// const extensionPath = context.extensionPath // the directory where the extension is installed, might be useful later... was included in webviewProvider code
-		this._extensionUri = context.extensionUri
-
-		let temp_res: typeof this._res | undefined = undefined
-		this.webview = new Promise((res, rej) => { temp_res = res })
-		if (!temp_res) throw new Error("Void sidebar provider: resolver was undefined")
-		this._res = temp_res
-	}
-
-	// called by us
-	updateWebviewHTML(webview: vscode.Webview) {
-		this._webviewDeps = []
-
-		const scriptUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'dist/sidebar/index.js'));
-		const stylesUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'dist/sidebar/styles.css'));
-		const rootUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri));
-		const nonce = getNonce();
-
-		const webviewHTML = `<!DOCTYPE html>
-          <html lang="en">
-          <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-            <title>Custom View</title>
-            <meta http-equiv="Content-Security-Policy" content="img-src vscode-resource: https:; script-src 'nonce-${nonce}'; style-src vscode-resource: 'unsafe-inline' http: https: data:;">
-            <base href="${rootUri}/">
-            <link href="${stylesUri}" rel="stylesheet">
-          </head>
-          <body>
-            <div id="root"></div>
-            <script nonce="${nonce}" src="${scriptUri}"></script>
-          </body>
-          </html>`;
-
-		webview.html = webviewHTML;
-	}
-
-
-	// called internally by vscode
-	resolveWebviewView(
-		webviewView: vscode.WebviewView,
-		context: vscode.WebviewViewResolveContext,
-		token: vscode.CancellationToken,
-	) {
-
-		const webview = webviewView.webview;
-
-		webview.options = {
-			enableScripts: true,
-			localResourceRoots: [this._extensionUri]
-		};
-
-		this.updateWebviewHTML(webview);
-
-		// resolve webview and _webviewView
-		this._res(webview);
-		// this._webviewView = webviewView;
-	}
-}

extensions/void/src/common/sendLLMMessage.ts

@@ -1,295 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import OpenAI from 'openai';
-import { Ollama } from 'ollama/browser'
-import { VoidConfig } from '../sidebar/contextForConfig';
-
-
-
-
-type OnText = (newText: string, fullText: string) => void
-
-export type LLMMessage = {
-	role: 'user' | 'assistant',
-	content: string
-}
-
-type SendLLMMessageFnTypeInternal = (params: {
-	messages: LLMMessage[],
-	onText: OnText,
-	onFinalMessage: (input: string) => void,
-	onError: (error: string) => void,
-	voidConfig: VoidConfig,
-})
-	=> {
-		abort: () => void
-	}
-
-type SendLLMMessageFnTypeExternal = (params: {
-	messages: LLMMessage[],
-	onText: OnText,
-	onFinalMessage: (input: string) => void,
-	onError: (error: string) => void,
-	voidConfig: VoidConfig | null,
-})
-	=> {
-		abort: () => void
-	}
-
-
-
-
-// Anthropic
-const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
-
-	const anthropic = new Anthropic({ apiKey: voidConfig.anthropic.apikey, dangerouslyAllowBrowser: true }); // defaults to process.env["ANTHROPIC_API_KEY"]
-
-	const stream = anthropic.messages.stream({
-		model: voidConfig.anthropic.model,
-		max_tokens: parseInt(voidConfig.anthropic.maxTokens),
-		messages: messages,
-	});
-
-	let did_abort = false
-
-	// when receive text
-	stream.on('text', (newText, fullText) => {
-		if (did_abort) return
-		onText(newText, fullText)
-	})
-
-	// when we get the final message on this stream (or when error/fail)
-	stream.on('finalMessage', (claude_response) => {
-		if (did_abort) return
-		// stringify the response's content
-		let content = claude_response.content.map(c => { if (c.type === 'text') { return c.text } }).join('\n');
-		onFinalMessage(content)
-	})
-
-	stream.on('error', (error) => {
-		// the most common error will be invalid API key (401), so we handle this with a nice message
-		if (error instanceof Anthropic.APIError && error.status === 401) {
-			onError('Invalid API key.')
-		}
-		else {
-			onError(error.message)
-		}
-	})
-
-	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
-	const abort = () => {
-		// stream.controller.abort() // TODO need to test this to make sure it works, it might throw an error
-		did_abort = true
-	}
-
-	return { abort }
-
-};
-
-
-
-
-// OpenAI, OpenRouter, OpenAICompatible
-const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
-
-	let didAbort = false
-	let fullText = ''
-
-	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
-	let abort: () => void = () => {
-		didAbort = true;
-	};
-
-	let openai: OpenAI
-	let options: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
-
-	if (voidConfig.default.whichApi === 'openAI') {
-		openai = new OpenAI({ apiKey: voidConfig.openAI.apikey, dangerouslyAllowBrowser: true });
-		options = { model: voidConfig.openAI.model, messages: messages, stream: true, }
-	}
-	else if (voidConfig.default.whichApi === 'openRouter') {
-		openai = new OpenAI({
-			baseURL: "https://openrouter.ai/api/v1", apiKey: voidConfig.openRouter.apikey, dangerouslyAllowBrowser: true,
-			defaultHeaders: {
-				"HTTP-Referer": 'https://voideditor.com', // Optional, for including your app on openrouter.ai rankings.
-				"X-Title": 'Void Editor', // Optional. Shows in rankings on openrouter.ai.
-			},
-		});
-		options = { model: voidConfig.openRouter.model, messages: messages, stream: true, }
-	}
-	else if (voidConfig.default.whichApi === 'openAICompatible') {
-		openai = new OpenAI({ baseURL: voidConfig.openAICompatible.endpoint, apiKey: voidConfig.openAICompatible.apikey, dangerouslyAllowBrowser: true })
-		options = { model: voidConfig.openAICompatible.model, messages: messages, stream: true, }
-	}
-	else {
-		console.error(`sendOpenAIMsg: invalid whichApi: ${voidConfig.default.whichApi}`)
-		throw new Error(`voidConfig.whichAPI was invalid: ${voidConfig.default.whichApi}`)
-	}
-
-	openai.chat.completions
-		.create(options)
-		.then(async response => {
-			abort = () => {
-				// response.controller.abort()
-				didAbort = true;
-			}
-			// when receive text
-			for await (const chunk of response) {
-				if (didAbort) return;
-				const newText = chunk.choices[0]?.delta?.content || '';
-				fullText += newText;
-				onText(newText, fullText);
-			}
-			onFinalMessage(fullText);
-		})
-		// when error/fail - this catches errors of both .create() and .then(for await)
-		.catch(error => {
-			if (error instanceof OpenAI.APIError) {
-				if (error.status === 401) {
-					onError('Invalid API key.');
-				}
-				else {
-					onError(error.message);
-				}
-			}
-			else {
-				onError(error);
-			}
-		})
-
-	return { abort };
-};
-
-
-// Ollama
-export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
-
-	let didAbort = false
-	let fullText = ""
-
-	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
-	let abort = () => {
-		didAbort = true;
-	};
-
-	const ollama = new Ollama({ host: voidConfig.ollama.endpoint })
-
-	ollama.chat({
-		model: voidConfig.ollama.model,
-		messages: messages,
-		stream: true,
-	})
-		.then(async stream => {
-			abort = () => {
-				// ollama.abort()
-				didAbort = true
-			}
-			// iterate through the stream
-			for await (const chunk of stream) {
-				if (didAbort) return;
-				const newText = chunk.message.content;
-				fullText += newText;
-				onText(newText, fullText);
-			}
-			onFinalMessage(fullText);
-
-		})
-		// when error/fail
-		.catch(error => {
-			onError(error)
-		})
-
-	return { abort };
-};
-
-
-
-// Greptile
-// https://docs.greptile.com/api-reference/query
-// https://docs.greptile.com/quickstart#sample-response-streamed
-
-const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
-
-	let didAbort = false
-	let fullText = ''
-
-	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
-	let abort: () => void = () => { didAbort = true }
-
-
-	fetch('https://api.greptile.com/v2/query', {
-		method: 'POST',
-		headers: {
-			"Authorization": `Bearer ${voidConfig.greptile.apikey}`,
-			"X-Github-Token": `${voidConfig.greptile.githubPAT}`,
-			"Content-Type": `application/json`,
-		},
-		body: JSON.stringify({
-			messages,
-			stream: true,
-			repositories: [voidConfig.greptile.repoinfo]
-		}),
-	})
-		// this is {message}\n{message}\n{message}...\n
-		.then(async response => {
-			const text = await response.text()
-			console.log('got greptile', text)
-			return JSON.parse(`[${text.trim().split('\n').join(',')}]`)
-		})
-		// TODO make this actually stream, right now it just sends one message at the end
-		.then(async responseArr => {
-			if (didAbort)
-				return
-
-			for (let response of responseArr) {
-
-				const type: string = response['type']
-				const message = response['message']
-
-				// when receive text
-				if (type === 'message') {
-					fullText += message
-					onText(message, fullText)
-				}
-				else if (type === 'sources') {
-					const { filepath, linestart, lineend } = message as { filepath: string, linestart: number | null, lineend: number | null }
-					fullText += filepath
-					onText(filepath, fullText)
-				}
-				// type: 'status' with an empty 'message' means last message
-				else if (type === 'status') {
-					if (!message) {
-						onFinalMessage(fullText)
-					}
-				}
-			}
-
-		})
-		.catch(e => {
-			onError(e)
-		});
-
-	return { abort }
-
-}
-
-
-
-export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
-	if (!voidConfig) return { abort: () => { } }
-
-	switch (voidConfig.default.whichApi) {
-		case 'anthropic':
-			return sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig });
-		case 'openAI':
-		case 'openRouter':
-		case 'openAICompatible':
-			return sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig });
-		case 'ollama':
-			return sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig });
-		case 'greptile':
-			return sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig });
-		default:
-			onError(`Error: whichApi was ${voidConfig.default.whichApi}, which is not recognized!`)
-			return { abort: () => { } }
-	}
-}

extensions/void/src/extension.ts

@@ -1,160 +0,0 @@
-import * as vscode from 'vscode';
-import { DisplayChangesProvider } from './DisplayChangesProvider';
-import { BaseDiffArea, ChatThreads, MessageFromSidebar, MessageToSidebar } from './shared_types';
-import { SidebarWebviewProvider } from './SidebarWebviewProvider';
-
-const readFileContentOfUri = async (uri: vscode.Uri) => {
-	return Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf8')
-		.replace(/\r\n/g, '\n') // replace windows \r\n with \n
-}
-
-export function activate(context: vscode.ExtensionContext) {
-
-	// 1. Mount the chat sidebar
-	const webviewProvider = new SidebarWebviewProvider(context);
-	context.subscriptions.push(
-		vscode.window.registerWebviewViewProvider(SidebarWebviewProvider.viewId, webviewProvider, { webviewOptions: { retainContextWhenHidden: true } })
-	);
-
-	// 2. Activate the sidebar on ctrl+l
-	context.subscriptions.push(
-		vscode.commands.registerCommand('void.ctrl+l', () => {
-
-			const editor = vscode.window.activeTextEditor
-			if (!editor)
-				return
-
-			// show the sidebar
-			vscode.commands.executeCommand('workbench.view.extension.voidViewContainer');
-			// vscode.commands.executeCommand('vscode.moveViewToPanel', CustomViewProvider.viewId); // move to aux bar
-
-			// get the text the user is selecting
-			const selectionStr = editor.document.getText(editor.selection);
-
-			// get the range of the selection
-			const selectionRange = editor.selection;
-
-			// get the file the user is in
-			const filePath = editor.document.uri;
-
-			// send message to the webview (Sidebar.tsx)
-			webviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+l', selection: { selectionStr, selectionRange, filePath } } satisfies MessageToSidebar));
-		})
-	);
-
-	// 3. Show an approve/reject codelens above each change
-	const displayChangesProvider = new DisplayChangesProvider();
-	context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', displayChangesProvider));
-
-	// 4. Add approve/reject commands
-	context.subscriptions.push(vscode.commands.registerCommand('void.acceptDiff', async (params) => {
-		displayChangesProvider.acceptDiff(params)
-	}));
-	context.subscriptions.push(vscode.commands.registerCommand('void.rejectDiff', async (params) => {
-		displayChangesProvider.rejectDiff(params)
-	}));
-
-	// 5. Receive messages from sidebar
-	webviewProvider.webview.then(
-		webview => {
-
-			// top navigation bar commands
-			context.subscriptions.push(vscode.commands.registerCommand('void.startNewThread', async () => {
-				webview.postMessage({ type: 'startNewThread' } satisfies MessageToSidebar)
-			}))
-			context.subscriptions.push(vscode.commands.registerCommand('void.toggleThreadSelector', async () => {
-				webview.postMessage({ type: 'toggleThreadSelector' } satisfies MessageToSidebar)
-			}))
-			context.subscriptions.push(vscode.commands.registerCommand('void.toggleSettings', async () => {
-				webview.postMessage({ type: 'toggleSettings' } satisfies MessageToSidebar)
-			}));
-
-			// Receive messages in the extension from the sidebar webview (messages are sent using `postMessage`)
-			webview.onDidReceiveMessage(async (m: MessageFromSidebar) => {
-
-				if (m.type === 'requestFiles') {
-
-					// get contents of all file paths
-					const files = await Promise.all(
-						m.filepaths.map(async (filepath) => ({ filepath, content: await readFileContentOfUri(filepath) }))
-					)
-
-					// send contents to webview
-					webview.postMessage({ type: 'files', files, } satisfies MessageToSidebar)
-
-				} else if (m.type === 'applyChanges') {
-
-					const editor = vscode.window.activeTextEditor
-					if (!editor) {
-						vscode.window.showInformationMessage('No active editor!')
-						return
-					}
-
-					// create an area to show diffs
-					const diffArea: BaseDiffArea = {
-						startLine: 0, // in ctrl+L the start and end lines are the full document
-						endLine: editor.document.lineCount,
-						originalStartLine: 0,
-						originalEndLine: editor.document.lineCount,
-						originalCode: await readFileContentOfUri(editor.document.uri),
-					}
-					displayChangesProvider.addDiffArea(editor.document.uri, diffArea)
-
-
-					// write new code `m.code` to the document
-					// TODO update like this:
-					// this._weAreEditing = true
-					// await vscode.workspace.applyEdit(workspaceEdit)
-					// await vscode.workspace.save(docUri)
-					// this._weAreEditing = false
-					await editor.edit(editBuilder => {
-						editBuilder.replace(new vscode.Range(diffArea.startLine, 0, diffArea.endLine, Number.MAX_SAFE_INTEGER), m.code);
-					});
-
-					// rediff the changes based on the diffAreas
-					displayChangesProvider.refreshDiffAreas(editor.document.uri)
-
-				}
-				else if (m.type === 'getPartialVoidConfig') {
-					const partialVoidConfig = context.globalState.get('partialVoidConfig') ?? {}
-					webview.postMessage({ type: 'partialVoidConfig', partialVoidConfig } satisfies MessageToSidebar)
-				}
-				else if (m.type === 'persistPartialVoidConfig') {
-					const partialVoidConfig = m.partialVoidConfig
-					context.globalState.update('partialVoidConfig', partialVoidConfig)
-				}
-				else if (m.type === 'getAllThreads') {
-					const threads: ChatThreads = context.workspaceState.get('allThreads') ?? {}
-					webview.postMessage({ type: 'allThreads', threads } satisfies MessageToSidebar)
-				}
-				else if (m.type === 'persistThread') {
-					const threads: ChatThreads = context.workspaceState.get('allThreads') ?? {}
-					const updatedThreads: ChatThreads = { ...threads, [m.thread.id]: m.thread }
-					context.workspaceState.update('allThreads', updatedThreads)
-				}
-				else {
-					console.error('unrecognized command', m)
-				}
-			})
-		}
-	)
-
-
-
-
-	// Gets called when user presses ctrl + k (mounts ctrl+k-style codelens)
-	// TODO need to build this
-	// const ctrlKCodeLensProvider = new CtrlKCodeLensProvider();
-	// context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', ctrlKCodeLensProvider));
-	// context.subscriptions.push(
-	// 	vscode.commands.registerCommand('void.ctrl+k', () => {
-	// 		const editor = vscode.window.activeTextEditor;
-	// 		if (!editor)
-	// 			return
-	// 		ctrlKCodeLensProvider.addNewCodeLens(editor.document, editor.selection);
-	// 		// vscode.commands.executeCommand('editor.action.showHover'); // apparently this refreshes the codelenses by having the internals call provideCodeLenses
-	// 	})
-	// )
-
-}
-

extensions/void/src/findDiffs.ts

@@ -1,277 +0,0 @@
-
-import * as vscode from 'vscode';
-// import { diffLines, Change } from 'diff';
-import { BaseDiff } from './shared_types';
-
-import { diff_match_patch } from 'diff-match-patch';
-
-
-const diffLines = (text1: string, text2: string) => {
-	var dmp = new diff_match_patch();
-	var a = dmp.diff_linesToChars_(text1, text2);
-	var lineText1 = a.chars1;
-	var lineText2 = a.chars2;
-	var lineArray = a.lineArray;
-	var diffs = dmp.diff_main(lineText1, lineText2, false);
-	dmp.diff_charsToLines_(diffs, lineArray);
-	// dmp.diff_cleanupSemantic(diffs);
-	return diffs;
-}
-
-
-// TODO use a better diff algorithm
-export const findDiffs = (oldText: string, newText: string): BaseDiff[] => {
-
-	const diffs = diffLines(oldText, newText);
-
-	const blocks: BaseDiff[] = [];
-	let reprBlock: string[] = [];
-	let deletedBlock: string[] = [];
-	let insertedBlock: string[] = [];
-	let insertedLine = 0;
-	let deletedLine = 0;
-	let insertedStart = 0;
-	let deletedStart = 0;
-
-	diffs.forEach(([operation, text]) => {
-
-		const lines = text.split('\n');
-
-		switch (operation) {
-
-			// insertion
-			case 1:
-				if (reprBlock.length === 0) { reprBlock.push('@@@@'); }
-				if (insertedBlock.length === 0) insertedStart = insertedLine;
-				insertedLine += lines.length - 1; // Update only the line count for new text
-				insertedBlock.push(text);
-				reprBlock.push(lines.map(line => `+ ${line}`).join('\n'));
-				break;
-
-			// deletion
-			case -1:
-				if (reprBlock.length === 0) { reprBlock.push('@@@@'); }
-				if (deletedBlock.length === 0) deletedStart = deletedLine;
-				deletedLine += lines.length - 1; // Update only the line count for old text
-				deletedBlock.push(text);
-				reprBlock.push(lines.map(line => `- ${line}`).join('\n'));
-				break;
-
-			// no change
-			case 0:
-				// If we have a pending block, add it to the blocks array
-				if (insertedBlock.length > 0 || deletedBlock.length > 0) {
-					blocks.push({
-						code: reprBlock.join(''),
-						deletedCode: deletedBlock.join(''),
-						insertedCode: insertedBlock.join(''),
-						deletedRange: new vscode.Range(deletedStart, 0, deletedLine, Number.MAX_SAFE_INTEGER),
-						insertedRange: new vscode.Range(insertedStart, 0, insertedLine, Number.MAX_SAFE_INTEGER),
-					});
-				}
-
-				// Reset the block variables
-				reprBlock = [];
-				deletedBlock = [];
-				insertedBlock = [];
-
-				// Update line counts for unchanged text
-				insertedLine += lines.length - 1;
-				deletedLine += lines.length - 1;
-
-				break;
-		}
-	});
-
-	// Add any remaining blocks after the loop ends
-	if (insertedBlock.length > 0 || deletedBlock.length > 0) {
-		blocks.push({
-			code: reprBlock.join(''),
-			deletedCode: deletedBlock.join(''),
-			insertedCode: insertedBlock.join(''),
-			deletedRange: new vscode.Range(deletedStart, 0, deletedLine, Number.MAX_SAFE_INTEGER),
-			insertedRange: new vscode.Range(insertedStart, 0, insertedLine, Number.MAX_SAFE_INTEGER),
-		});
-	}
-
-	return blocks;
-};
-
-
-
-// export const findDiffs = (oldText: string, newText: string): DiffBlock[] => {
-
-// 	const diffs = diffLines(oldText, newText);
-
-// 	const blocks: DiffBlock[] = [];
-
-// 	let reprBlock: string[] = [];
-// 	let deletedBlock: string[] = [];
-// 	let insertedBlock: string[] = [];
-
-// 	let insertedEnd = 0;
-// 	let deletedEnd = 0;
-// 	let insertedStart = 0;
-// 	let deletedStart = 0;
-
-// 	diffs.forEach(part => {
-
-// 		part.count = part.count ?? 0
-
-// 		// if the part is an addition or deletion, add it to the current block
-// 		if (part.added || part.removed) {
-// 			if (reprBlock.length === 0) { reprBlock.push('@@@@'); }
-// 			if (part.added) {
-// 				if (insertedBlock.length === 0) insertedStart = insertedEnd;
-// 				insertedEnd += part.count
-// 				insertedBlock.push(part.value);
-// 				reprBlock.push(part.value.split('\n').map(line => `+ ${line}`).join('\n'));
-// 			}
-// 			if (part.removed) {
-// 				if (deletedBlock.length === 0) deletedStart = deletedEnd;
-// 				deletedEnd += part.count
-// 				deletedBlock.push(part.value);
-// 				reprBlock.push(part.value.split('\n').map(line => `- ${line}`).join('\n'));
-// 			}
-// 		}
-
-// 		// if the part is unchanged, finalize the block and add it to the array
-// 		else {
-// 			// if the block is not null, add it to the array
-// 			if (insertedBlock.length > 0 || deletedBlock.length > 0) {
-// 				blocks.push({
-// 					code: reprBlock.join('\n'),
-// 					deletedCode: deletedBlock.join(''),
-// 					insertedCode: insertedBlock.join(''),
-// 					deletedRange: new vscode.Range(deletedStart, 0, deletedEnd, Number.MAX_SAFE_INTEGER),
-// 					insertedRange: new vscode.Range(insertedStart, 0, insertedEnd, Number.MAX_SAFE_INTEGER),
-// 				});
-// 			}
-
-// 			// update block variables
-// 			reprBlock = [];
-// 			deletedBlock = [];
-// 			insertedBlock = [];
-// 			insertedEnd += part.count;
-// 			deletedEnd += part.count;
-
-// 		}
-
-// 	})
-
-// 	// finally, add the last block to the array
-// 	if (insertedBlock.length > 0 || deletedBlock.length > 0) {
-// 		blocks.push({
-// 			code: reprBlock.join('\n'),
-// 			deletedCode: deletedBlock.join(''),
-// 			insertedCode: insertedBlock.join(''),
-// 			deletedRange: new vscode.Range(deletedStart, 0, deletedEnd, Number.MAX_SAFE_INTEGER),
-// 			insertedRange: new vscode.Range(insertedStart, 0, insertedEnd, Number.MAX_SAFE_INTEGER),
-// 		});
-// 	}
-
-// 	return blocks;
-
-// }
-
-
-
-
-
-
-
-
-
-
-
-// import { diffLines, Change } from 'diff';
-
-// export type SuggestedEdit = {
-// 	// start/end of current file
-// 	startLine: number;
-// 	endLine: number;
-
-// 	// start/end of original file
-// 	originalStartLine: number,
-// 	originalEndLine: number,
-
-// 	// original content (originalfile[originalStart...originalEnd])
-// 	originalContent: string;
-// 	newContent: string;
-// }
-
-// export function getDiffedLines(oldStr: string, newStr: string) {
-// 	// an ordered list of every original line, line added to the new file, and line removed from the old file (order is unambiguous, think about it)
-// 	const lineByLineChanges: Change[] = diffLines(oldStr, newStr);
-// 	console.debug('Line by line changes', lineByLineChanges)
-
-// 	lineByLineChanges.push({ value: '' }) // add a dummy so we flush any streaks we haven't yet at the very end (!line.added && !line.removed)
-
-// 	let oldFileLineNum: number = 0;
-// 	let newFileLineNum: number = 0;
-
-// 	let streakStartInNewFile: number | undefined = undefined
-// 	let streakStartInOldFile: number | undefined = undefined
-
-// 	let oldStrLines = oldStr.split('\n')
-// 	let newStrLines = newStr.split('\n')
-
-// 	const replacements: SuggestedEdit[] = []
-
-// 	for (let line of lineByLineChanges) {
-// 		// no change on this line
-// 		if (!line.added && !line.removed) {
-// 			// if we were on a streak, add it
-// 			if (streakStartInNewFile !== undefined) {
-
-// 				const startLine = streakStartInNewFile
-// 				const endLine = newFileLineNum - 1 // don't include current line, the edit was up to this line but not including it
-// 				const newContent = newStrLines.slice(startLine, endLine + 1).join('\n')
-
-// 				const originalStartLine = streakStartInOldFile!
-// 				const originalEndLine = oldFileLineNum - 1 // don't include current line, the edit was up to this line but not including it
-// 				const originalContent = oldStrLines.slice(originalStartLine, originalEndLine + 1).join('\n')
-
-// 				const replacement: SuggestedEdit = { startLine, endLine, newContent, originalStartLine, originalEndLine, originalContent }
-
-// 				replacements.push(replacement)
-// 				streakStartInNewFile = undefined
-// 				streakStartInOldFile = undefined
-// 			}
-
-// 			oldFileLineNum += line.count ?? 0;
-// 			newFileLineNum += line.count ?? 0;
-// 		}
-
-
-// 		// line was removed from old file
-// 		else if (line.removed) {
-
-// 			// if we weren't on a streak, start one on this current line num
-// 			if (streakStartInNewFile === undefined) {
-// 				streakStartInNewFile = newFileLineNum
-// 				streakStartInOldFile = oldFileLineNum
-// 			}
-
-// 			oldFileLineNum += line.count ?? 0 // we processed the line so add 1
-// 		}
-
-// 		// line was added to new file
-// 		else if (line.added) {
-
-// 			// if we weren't on a streak, start one on this current line num
-// 			if (streakStartInNewFile === undefined) {
-// 				streakStartInNewFile = newFileLineNum
-// 				streakStartInOldFile = oldFileLineNum
-// 			}
-
-// 			newFileLineNum += line.count ?? 0; // we processed the line so add 1
-// 		}
-
-// 	} // end for
-
-// 	console.debug('Replacements', replacements)
-
-// 	return replacements
-
-// }

extensions/void/src/shared_types.ts

@@ -1,94 +0,0 @@
-
-import * as vscode from 'vscode';
-import { PartialVoidConfig } from './sidebar/contextForConfig';
-
-
-
-// a selection is a frozen snapshot
-type CodeSelection = { selectionStr: string, selectionRange: vscode.Range, filePath: vscode.Uri }
-
-type File = { filepath: vscode.Uri, content: string }
-
-// an area that is currently being diffed
-type BaseDiffArea = {
-	// use `startLine` and `endLine` instead of `range` for mutibility
-	// bounds are relative to the file, inclusive
-	startLine: number;
-	endLine: number;
-	originalStartLine: number,
-	originalEndLine: number,
-	originalCode: string, // the original chunk of code (not necessarily the whole file)
-	// `newCode: string,` is not included because it is the code in the actual file, `document.text()[startline: endLine + 1]`
-}
-
-type DiffArea = BaseDiffArea & { diffareaid: number }
-
-// the return type of diff creator
-type BaseDiff = {
-	code: string; // representation of the diff in text
-	deletedRange: vscode.Range; // relative to the file, inclusive
-	insertedRange: vscode.Range;
-	deletedCode: string;
-	insertedCode: string;
-}
-
-// each diff on the user's screen
-type Diff = {
-	diffid: number,
-	lenses: vscode.CodeLens[],
-} & BaseDiff
-
-// editor -> sidebar
-type MessageToSidebar = (
-	| { type: 'ctrl+l', selection: CodeSelection } // user presses ctrl+l in the editor
-	| { type: 'files', files: { filepath: vscode.Uri, content: string }[] }
-	| { type: 'partialVoidConfig', partialVoidConfig: PartialVoidConfig }
-	| { type: 'allThreads', threads: ChatThreads }
-	| { type: 'startNewThread' }
-	| { type: 'toggleThreadSelector' }
-	| { type: 'toggleSettings' }
-)
-
-// sidebar -> editor
-type MessageFromSidebar = (
-	| { type: 'applyChanges', code: string } // user clicks "apply" in the sidebar
-	| { type: 'requestFiles', filepaths: vscode.Uri[] }
-	| { type: 'getPartialVoidConfig' }
-	| { type: 'persistPartialVoidConfig', partialVoidConfig: PartialVoidConfig }
-	| { type: 'getAllThreads' }
-	| { type: 'persistThread', thread: ChatThreads[string] }
-)
-
-
-type ChatThreads = {
-	[id: string]: {
-		id: string; // store the id here too
-		createdAt: string;
-		messages: ChatMessage[];
-	}
-}
-
-type ChatMessage =
-	| {
-		role: "user";
-		content: string; // content sent to the llm
-		displayContent: string; // content displayed to user
-		selection: CodeSelection | null; // the user's selection
-		files: vscode.Uri[]; // the files sent in the message
-	}
-	| {
-		role: "assistant";
-		content: string; // content received from LLM
-		displayContent: string; // content displayed to user (this is the same as content for now)
-	}
-
-export {
-	BaseDiff, BaseDiffArea,
-	Diff, DiffArea,
-	CodeSelection,
-	File,
-	MessageFromSidebar,
-	MessageToSidebar,
-	ChatThreads,
-	ChatMessage,
-}

extensions/void/src/sidebar/Sidebar.tsx

@@ -1,72 +0,0 @@
-import React, { useState, useEffect, useRef, useCallback, FormEvent } from "react"
-import { CodeSelection, ChatMessage, MessageToSidebar } from "../shared_types"
-import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode, useOnVSCodeMessage } from "./getVscodeApi"
-
-import { SidebarThreadSelector } from "./SidebarThreadSelector";
-import { useThreads } from "./contextForThreads";
-import { SidebarChat } from "./SidebarChat";
-import { SidebarSettings } from './SidebarSettings';
-
-
-
-const Sidebar = () => {
-	const [tab, setTab] = useState<'threadSelector' | 'chat' | 'settings'>('chat')
-
-	// if they pressed the + to add a new chat
-	useOnVSCodeMessage('startNewThread', (m) => {
-		setTab('chat')
-	})
-
-	// if they toggled thread selector
-	useOnVSCodeMessage('toggleThreadSelector', (m) => {
-		if (tab === 'threadSelector')
-			setTab('chat')
-		else
-			setTab('threadSelector')
-	})
-
-	// if they toggled settings
-	useOnVSCodeMessage('toggleSettings', (m) => {
-		if (tab === 'settings')
-			setTab('chat')
-		else
-			setTab('settings')
-	})
-
-
-	// Receive messages from the VSCode extension
-	useEffect(() => {
-		const listener = (event: MessageEvent) => {
-			const m = event.data as MessageToSidebar;
-			onMessageFromVSCode(m)
-		}
-		window.addEventListener('message', listener);
-		return () => { window.removeEventListener('message', listener) }
-	}, [])
-
-
-
-	return <>
-		<div className={`flex flex-col h-screen w-full`}>
-
-			<div className={`mb-2 max-h-[30vh] overflow-y-auto ${tab !== 'threadSelector' ? 'hidden' : ''}`}>
-				<SidebarThreadSelector onClose={() => setTab('chat')} />
-			</div>
-
-			<div className={`${tab !== 'chat' && tab !== 'threadSelector' ? 'hidden' : ''}`}>
-				<SidebarChat />
-			</div>
-
-			<div className={`${tab !== 'settings' ? 'hidden' : ''}`}>
-				<SidebarSettings />
-			</div>
-
-
-
-		</div>
-
-	</>
-
-}
-
-export default Sidebar

extensions/void/src/sidebar/SidebarChat.tsx

@@ -1,288 +0,0 @@
-import React, { FormEvent, useCallback, useEffect, useRef, useState } from "react";
-
-
-import { marked } from 'marked';
-import MarkdownRender from "./markdown/MarkdownRender";
-import BlockCode from "./markdown/BlockCode";
-import { SelectedFiles } from "./components/SelectedFiles";
-import { File, ChatMessage, CodeSelection } from "../shared_types";
-import * as vscode from 'vscode'
-import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode, useOnVSCodeMessage } from "./getVscodeApi";
-import { useThreads } from "./contextForThreads";
-import { sendLLMMessage } from "../common/sendLLMMessage";
-import { useVoidConfig } from "./contextForConfig";
-
-
-
-const filesStr = (fullFiles: File[]) => {
-	return fullFiles.map(({ filepath, content }) =>
-		`
-${filepath.fsPath}
-\`\`\`
-${content}
-\`\`\``).join('\n')
-}
-
-const userInstructionsStr = (instructions: string, files: File[], selection: CodeSelection | null) => {
-	let str = '';
-
-	if (files.length > 0) {
-		str += filesStr(files);
-	}
-
-	if (selection) {
-		str += `
-I am currently selecting this code:
-\t\`\`\`${selection.selectionStr}\`\`\`
-`;
-	}
-
-	if (files.length > 0 && selection) {
-		str += `
-Please edit the selected code or the entire file following these instructions:
-`;
-	} else if (files.length > 0) {
-		str += `
-Please edit the file following these instructions:
-`;
-	} else if (selection) {
-		str += `
-Please edit the selected code following these instructions:
-`;
-	}
-
-	str += `
-\t${instructions}
-`;
-	if (files.length > 0) {
-		str += `
-\tIf you make a change, rewrite the entire file.
-`; // TODO don't rewrite the whole file on prompt, instead rewrite it when click Apply
-	}
-	return str;
-};
-
-const ChatBubble = ({ chatMessage }: { chatMessage: ChatMessage }) => {
-
-	const role = chatMessage.role
-	const children = chatMessage.displayContent
-
-	if (!children)
-		return null
-
-	let chatbubbleContents: React.ReactNode
-
-	if (role === 'user') {
-		chatbubbleContents = <>
-			<SelectedFiles files={chatMessage.files} setFiles={null} />
-			{chatMessage.selection?.selectionStr && <BlockCode text={chatMessage.selection.selectionStr} hideToolbar />}
-			{children}
-		</>
-	}
-	else if (role === 'assistant') {
-
-		chatbubbleContents = <MarkdownRender string={children} /> // sectionsHTML
-	}
-
-
-	return <div className={`${role === 'user' ? 'text-right' : 'text-left'}`}>
-		<div className={`inline-block p-2 rounded-lg space-y-2 ${role === 'user' ? 'bg-vscode-input-bg text-vscode-input-fg' : ''} max-w-full`}>
-			{chatbubbleContents}
-		</div>
-	</div>
-}
-
-
-export const SidebarChat = () => {
-
-
-	// state of current message
-	const [selection, setSelection] = useState<CodeSelection | null>(null) // the code the user is selecting
-	const [files, setFiles] = useState<vscode.Uri[]>([]) // the names of the files in the chat
-	const [instructions, setInstructions] = useState('') // the user's instructions
-
-	// state of chat
-	const [messageStream, setMessageStream] = useState('')
-	const [isLoading, setIsLoading] = useState(false)
-	const abortFnRef = useRef<(() => void) | null>(null)
-
-	const [latestError, setLatestError] = useState('')
-
-	// higher level state
-	const { allThreads, currentThread, addMessageToHistory, startNewThread, switchToThread } = useThreads()
-	const { voidConfig } = useVoidConfig()
-
-	// if they pressed the + to add a new chat
-	useOnVSCodeMessage('startNewThread', (m) => {
-		// find a thread with 0 messages and switch to it
-		for (let threadId in allThreads) {
-			if (allThreads[threadId].messages.length === 0) {
-				switchToThread(threadId)
-				return
-			}
-		}
-		// start a new thread
-		startNewThread()
-	})
-
-	// if user pressed ctrl+l, add their selection to the sidebar
-	useOnVSCodeMessage('ctrl+l', (m) => {
-		setSelection(m.selection)
-		const filepath = m.selection.filePath
-
-		// add current file to the context if it's not already in the files array
-		if (!files.find(f => f.fsPath === filepath.fsPath))
-			setFiles(files => [...files, filepath])
-	})
-
-
-	const formRef = useRef<HTMLFormElement | null>(null)
-	const onSubmit = async (e: FormEvent<HTMLFormElement>) => {
-
-		e.preventDefault()
-		if (isLoading) return
-
-		setIsLoading(true)
-		setInstructions('');
-		formRef.current?.reset(); // reset the form's text when clear instructions or unexpected behavior happens
-		setSelection(null)
-		setFiles([])
-		setLatestError('')
-
-		// request file content from vscode and await response
-		getVSCodeAPI().postMessage({ type: 'requestFiles', filepaths: files })
-		const relevantFiles = await awaitVSCodeResponse('files')
-
-		// add message to chat history
-		const userContent = userInstructionsStr(instructions, relevantFiles.files, selection)
-		// console.log('prompt:\n', content)
-		const newHistoryElt: ChatMessage = { role: 'user', content: userContent, displayContent: instructions, selection, files }
-		addMessageToHistory(newHistoryElt)
-
-		// send message to LLM
-		let { abort } = sendLLMMessage({
-			messages: [...(currentThread?.messages ?? []).map(m => ({ role: m.role, content: m.content })), { role: 'user', content: userContent }],
-			onText: (newText, fullText) => setMessageStream(fullText),
-			onFinalMessage: (content) => {
-				// add assistant's message to chat history, and clear selection
-				const newHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content, }
-				addMessageToHistory(newHistoryElt)
-				setMessageStream('')
-				setIsLoading(false)
-			},
-			onError: (error) => {
-				// add assistant's message to chat history, and clear selection
-				let content = messageStream; // just use the current content
-				const newHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content, }
-				addMessageToHistory(newHistoryElt)
-				setMessageStream('')
-				setIsLoading(false)
-
-				setLatestError(error)
-			},
-			voidConfig: voidConfig
-		})
-		abortFnRef.current = abort
-
-	}
-
-	const onStop = useCallback(() => {
-		// abort claude
-		abortFnRef.current?.()
-
-		// if messageStream was not empty, add it to the history
-		const llmContent = messageStream || '(canceled)'
-		const newHistoryElt: ChatMessage = { role: 'assistant', displayContent: messageStream, content: llmContent }
-		addMessageToHistory(newHistoryElt)
-
-		setMessageStream('')
-		setIsLoading(false)
-
-	}, [addMessageToHistory, messageStream])
-
-	//Clear code selection
-	const clearSelection = () => {
-		setSelection(null);
-	};
-
-
-	return <>
-		<div className="overflow-y-auto overflow-x-hidden space-y-4">
-			{/* previous messages */}
-			{currentThread !== null && currentThread.messages.map((message, i) =>
-				<ChatBubble key={i} chatMessage={message} />
-			)}
-			{/* message stream */}
-			<ChatBubble chatMessage={{ role: 'assistant', content: messageStream, displayContent: messageStream }} />
-		</div>
-		{/* chatbar */}
-		<div className="shrink-0 py-4">
-			{/* selection */}
-			<div className="text-left">
-
-				<div className="relative">
-					<div className="input">
-						{/* selection */}
-						{(files.length || selection?.selectionStr) && <div className="p-2 pb-0 space-y-2">
-							{/* selected files */}
-							<SelectedFiles files={files} setFiles={setFiles} />
-							{/* selected code */}
-							{!!selection?.selectionStr && (
-								<BlockCode className="rounded bg-vscode-sidebar-bg" text={selection.selectionStr} toolbar={(
-									<button
-										onClick={clearSelection}
-										className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
-									>
-										Remove
-									</button>
-								)} />
-							)}
-						</div>}
-						<form
-							ref={formRef}
-							className="flex flex-row items-center rounded-md p-2"
-							onKeyDown={(e) => { if (e.key === 'Enter' && !e.shiftKey) onSubmit(e) }}
-
-							onSubmit={(e) => {
-								console.log('submit!')
-								e.preventDefault();
-								onSubmit(e)
-							}}>
-							{/* input */}
-
-							<textarea
-								onChange={(e) => { setInstructions(e.target.value) }}
-								className="w-full p-2 leading-tight resize-none max-h-[50vh] overflow-hidden bg-transparent border-none !outline-none"
-								placeholder="Ctrl+L to select"
-								rows={1}
-								onInput={e => { e.currentTarget.style.height = 'auto'; e.currentTarget.style.height = e.currentTarget.scrollHeight + 'px' }} // Adjust height dynamically
-							/>
-							{/* submit button */}
-							{isLoading ?
-								<button
-									onClick={onStop}
-									className="btn btn-primary rounded-r-lg max-h-10 p-2"
-									type='button'
-								>Stop</button>
-								: <button
-									className="btn btn-primary font-bold size-8 flex justify-center items-center rounded-full p-2 max-h-10"
-									disabled={!instructions}
-									type='submit'
-								>
-									<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-										<line x1="12" y1="19" x2="12" y2="5"></line>
-										<polyline points="5 12 12 5 19 12"></polyline>
-									</svg>
-								</button>
-							}
-						</form>
-					</div>
-				</div>
-			</div>
-
-			{latestError}
-		</div>
-	</>
-}
-
-

extensions/void/src/sidebar/SidebarSettings.tsx

@@ -1,96 +0,0 @@
-import React, { useState } from "react";
-import { configFields, useVoidConfig, VoidConfigField } from "./contextForConfig";
-
-
-const SettingOfFieldAndParam = ({ field, param }: { field: VoidConfigField, param: string }) => {
-	const { voidConfig, partialVoidConfig, voidConfigInfo, setConfigParam } = useVoidConfig()
-	const { enumArr, defaultVal, description } = voidConfigInfo[field][param]
-	const val = partialVoidConfig[field]?.[param] ?? defaultVal // current value of this item
-
-	const updateState = (newValue: string) => { setConfigParam(field, param, newValue) }
-
-	const resetButton = <button className='btn btn-sm' onClick={() => updateState(defaultVal)}>
-		<svg
-			className='size-5'
-			stroke="currentColor" fill="currentColor" strokeWidth="0" viewBox="0 0 16 16" height="200px" width="200px" xmlns="http://www.w3.org/2000/svg"><path fillRule="evenodd" clipRule="evenodd" d="M3.5 2v3.5L4 6h3.5V5H4.979l.941-.941a3.552 3.552 0 1 1 5.023 5.023L5.746 14.28l.72.72 5.198-5.198A4.57 4.57 0 0 0 5.2 3.339l-.7.7V2h-1z"></path>
-		</svg>
-	</button>
-
-	const inputElement = enumArr === undefined ?
-		// string
-		(<input
-			className='input p-1 w-full'
-			type="text"
-			value={val}
-			onChange={(e) => updateState(e.target.value)}
-		/>)
-		:
-		// enum
-		(<select
-			className='dropdown p-1 w-full'
-			value={val}
-			onChange={(e) => updateState(e.target.value)}
-		>
-			{enumArr.map((option) => (
-				<option key={option} value={option}>
-					{option}
-				</option>
-			))}
-		</select>)
-
-	return <div>
-		<label className='hidden'>{param}</label>
-		<span>{description}</span>
-		<div className='flex items-center'>
-			{inputElement}
-			{resetButton}
-		</div>
-	</div>
-}
-
-export const SidebarSettings = () => {
-
-	const { voidConfig, voidConfigInfo } = useVoidConfig()
-
-	const current_field = voidConfig.default['whichApi'] as VoidConfigField
-
-
-	return (
-		<div className='space-y-4 py-2 overflow-y-auto'>
-
-			{/* choose the field */}
-			<div className='outline-vscode-input-bg'>
-				<SettingOfFieldAndParam
-					field='default'
-					param='whichApi'
-				/>
-			</div>
-
-			<hr />
-
-			{/* render all fields, but hide the ones not visible for fast tab switching */}
-			{configFields.map(field => {
-				return <div
-					key={field}
-					className={`flex flex-col gap-y-2 ${field !== current_field ? 'hidden' : ''}`}
-				>
-					{Object.keys(voidConfigInfo[field]).map((param) => (
-						<SettingOfFieldAndParam
-							key={param}
-							field={field}
-							param={param}
-						/>
-					))}
-				</div>
-			})}
-
-			{/* Remove this after 10/21/24, this is just to give developers a heads up about the recent change  */}
-			<div className='pt-20'>
-				{`We recently updated Settings. To copy your old Void settings over, press Ctrl+Shift+P, `}
-				{`type 'Open User Settings (JSON)',`}
-				{` and look for 'void.'. `}
-			</div>
-		</div>
-	)
-}
-

extensions/void/src/sidebar/SidebarThreadSelector.tsx

@@ -1,77 +0,0 @@
-import React from "react";
-import { ThreadsProvider, useThreads } from "./contextForThreads";
-
-
-const truncate = (s: string) => {
-	let len = s.length
-	const TRUNC_AFTER = 16
-	if (len >= TRUNC_AFTER)
-		s = s.substring(0, TRUNC_AFTER) + '...'
-	return s
-}
-
-
-export const SidebarThreadSelector = ({ onClose }: { onClose: () => void }) => {
-	const { allThreads, currentThread, switchToThread } = useThreads()
-
-	// sorted by most recent to least recent
-	const sortedThreadIds = Object.keys(allThreads ?? {}).sort((threadId1, threadId2) => allThreads![threadId1].createdAt > allThreads![threadId2].createdAt ? -1 : 1)
-
-	return (
-		<div className="flex flex-col gap-y-1">
-
-			{/* X button at top right */}
-			<div className="text-right">
-				<button className="btn btn-sm" onClick={onClose}>
-					<svg
-						xmlns="http://www.w3.org/2000/svg"
-						fill="none"
-						viewBox="0 0 24 24"
-						stroke="currentColor"
-						className="size-4"
-					>
-						<path
-							strokeLinecap="round"
-							strokeLinejoin="round"
-							d="M6 18 18 6M6 6l12 12"
-						/>
-					</svg>
-				</button>
-			</div>
-
-			{/* a list of all the past threads */}
-			<div className='flex flex-col gap-y-1 max-h-80 overflow-y-auto'>
-				{sortedThreadIds.map((threadId) => {
-					if (!allThreads)
-						return <>Error: Threads not found.</>
-					const pastThread = allThreads[threadId]
-
-					let btnStringArr = []
-
-					let msg1 = truncate(allThreads[threadId].messages[0]?.displayContent ?? '(empty)')
-					btnStringArr.push(msg1)
-
-					let msg2 = truncate(allThreads[threadId].messages[1]?.displayContent ?? '')
-					if (msg2)
-						btnStringArr.push(msg2)
-
-					btnStringArr.push(allThreads[threadId].messages.length)
-
-					const btnString = btnStringArr.join(' / ')
-
-					return (
-						<button
-							key={pastThread.id}
-							className={`btn btn-sm rounded-sm ${pastThread.id === currentThread?.id ? "btn-primary" : "btn-secondary"}`}
-							onClick={() => switchToThread(pastThread.id)}
-							title={new Date(pastThread.createdAt).toLocaleString()}
-						>
-							{btnString}
-						</button>
-					)
-				})}
-			</div>
-
-		</div>
-	)
-}

extensions/void/src/sidebar/components/SelectedFiles.tsx

@@ -1,48 +0,0 @@
-import React from "react"
-import * as vscode from "vscode"
-
-const getBasename = (pathStr: string) => {
-	// "unixify" path
-	pathStr = pathStr.replace(/[/\\]+/g, "/") // replace any / or \ or \\ with /
-	const parts = pathStr.split("/") // split on /
-	return parts[parts.length - 1]
-}
-
-export const SelectedFiles = ({ files, setFiles, }: { files: vscode.Uri[], setFiles: null | ((files: vscode.Uri[]) => void) }) => {
-	return (
-		files.length !== 0 && (
-			<div className="flex flex-wrap -mx-1 -mb-1">
-				{files.map((filename, i) => (
-					<button
-						key={filename.path}
-						disabled={!setFiles}
-						className={`btn btn-secondary btn-sm border border-vscode-input-border rounded flex items-center space-x-2 mx-1 mb-1 disabled:cursor-default`}
-						type="button"
-						onClick={() => setFiles?.([...files.slice(0, i), ...files.slice(i + 1, Infinity)])}
-					>
-						<span>{getBasename(filename.fsPath)}</span>
-
-						{/* X button */}
-						{!!setFiles && <span className="">
-							<svg
-								xmlns="http://www.w3.org/2000/svg"
-								fill="none"
-								viewBox="0 0 24 24"
-								stroke="currentColor"
-								className="size-4"
-							>
-								<path
-									strokeLinecap="round"
-									strokeLinejoin="round"
-									d="M6 18 18 6M6 6l12 12"
-								/>
-							</svg>
-						</span>}
-					</button>
-				))}
-			</div>
-		)
-	)
-}
-
-

extensions/void/src/sidebar/contextForConfig.tsx

@@ -1,360 +0,0 @@
-import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
-import { awaitVSCodeResponse, getVSCodeAPI, useOnVSCodeMessage } from "./getVscodeApi"
-
-const configEnum = <EnumArr extends readonly string[]>(description: string, defaultVal: EnumArr[number], enumArr: EnumArr) => {
-	return {
-		description,
-		defaultVal,
-		enumArr,
-	}
-}
-
-const configString = (description: string, defaultVal: string) => {
-	return {
-		description,
-		defaultVal,
-		enumArr: undefined,
-	}
-}
-
-// fields you can customize (don't forget 'default' - it isn't included here!)
-export const configFields = [
-	'anthropic',
-	'openAI',
-	'greptile',
-	'ollama',
-	'openRouter',
-	'openAICompatible',
-	'azure'
-] as const
-
-
-
-const voidConfigInfo: Record<
-	typeof configFields[number] | 'default', {
-		[prop: string]: {
-			description: string,
-			enumArr?: readonly string[] | undefined,
-			defaultVal: string,
-		},
-	}
-> = {
-	default: {
-		whichApi: configEnum(
-			"API Provider.",
-			'anthropic',
-			configFields,
-		),
-	},
-	anthropic: {
-		apikey: configString('Anthropic API key.', ''),
-		model: configEnum(
-			"Anthropic model to use.",
-			'claude-3-5-sonnet-20240620',
-			[
-				"claude-3-5-sonnet-20240620",
-				"claude-3-opus-20240229",
-				"claude-3-sonnet-20240229",
-				"claude-3-haiku-20240307"
-			] as const,
-		),
-
-		maxTokens: configEnum(
-			"Anthropic max number of tokens to output.",
-			'8192',
-			[
-				"1024",
-				"2048",
-				"4096",
-				"8192"
-			] as const,
-		),
-	},
-	openAI: {
-		apikey: configString('OpenAI API key.', ''),
-		model: configEnum(
-			'OpenAI model to use.',
-			'gpt-4o',
-			[
-				"o1-preview",
-				"o1-mini",
-				"gpt-4o",
-				"gpt-4o-2024-05-13",
-				"gpt-4o-2024-08-06",
-				"gpt-4o-mini",
-				"gpt-4o-mini-2024-07-18",
-				"gpt-4-turbo",
-				"gpt-4-turbo-2024-04-09",
-				"gpt-4-turbo-preview",
-				"gpt-4-0125-preview",
-				"gpt-4-1106-preview",
-				"gpt-4",
-				"gpt-4-0613",
-				"gpt-3.5-turbo-0125",
-				"gpt-3.5-turbo",
-				"gpt-3.5-turbo-1106"
-			] as const
-		),
-	},
-	greptile: {
-		apikey: configString('Greptile API key.', ''),
-		githubPAT: configString('Github PAT that Greptile uses to access your repository', ''),
-		remote: configEnum(
-			'Repo location',
-			'github',
-			[
-				'github',
-				'gitlab'
-			] as const
-		),
-		repository: configString('Repository identifier in "owner/repository" format.', ''),
-		branch: configString('Name of the branch to use.', 'main'),
-	},
-	ollama: {
-		endpoint: configString(
-			'The Ollama endpoint. Start Ollama by running `OLLAMA_ORIGINS="vscode-webview://*" ollama serve`',
-			'http://127.0.0.1:11434'
-		),
-		model: configEnum(
-			'Ollama model to use.',
-			'llama3.1',
-			[
-				"codegemma",
-				"codegemma:2b",
-				"codegemma:7b",
-				"codellama",
-				"codellama:7b",
-				"codellama:13b",
-				"codellama:34b",
-				"codellama:70b",
-				"codellama:code",
-				"codellama:python",
-				"command-r",
-				"command-r:35b",
-				"command-r-plus",
-				"command-r-plus:104b",
-				"deepseek-coder-v2",
-				"deepseek-coder-v2:16b",
-				"deepseek-coder-v2:236b",
-				"falcon2",
-				"falcon2:11b",
-				"firefunction-v2",
-				"firefunction-v2:70b",
-				"gemma",
-				"gemma:2b",
-				"gemma:7b",
-				"gemma2",
-				"gemma2:2b",
-				"gemma2:9b",
-				"gemma2:27b",
-				"llama2",
-				"llama2:7b",
-				"llama2:13b",
-				"llama2:70b",
-				"llama3",
-				"llama3:8b",
-				"llama3:70b",
-				"llama3-chatqa",
-				"llama3-chatqa:8b",
-				"llama3-chatqa:70b",
-				"llama3-gradient",
-				"llama3-gradient:8b",
-				"llama3-gradient:70b",
-				"llama3.1",
-				"llama3.1:8b",
-				"llama3.1:70b",
-				"llama3.1:405b",
-				"llava",
-				"llava:7b",
-				"llava:13b",
-				"llava:34b",
-				"llava-llama3",
-				"llava-llama3:8b",
-				"llava-phi3",
-				"llava-phi3:3.8b",
-				"mistral",
-				"mistral:7b",
-				"mistral-large",
-				"mistral-large:123b",
-				"mistral-nemo",
-				"mistral-nemo:12b",
-				"mixtral",
-				"mixtral:8x7b",
-				"mixtral:8x22b",
-				"moondream",
-				"moondream:1.8b",
-				"openhermes",
-				"openhermes:v2.5",
-				"phi3",
-				"phi3:3.8b",
-				"phi3:14b",
-				"phi3.5",
-				"phi3.5:3.8b",
-				"qwen",
-				"qwen:7b",
-				"qwen:14b",
-				"qwen:32b",
-				"qwen:72b",
-				"qwen:110b",
-				"qwen2",
-				"qwen2:0.5b",
-				"qwen2:1.5b",
-				"qwen2:7b",
-				"qwen2:72b",
-				"smollm",
-				"smollm:135m",
-				"smollm:360m",
-				"smollm:1.7b"
-			] as const
-		),
-	},
-	openRouter: {
-		model: configString(
-			'OpenRouter model to use.',
-			'openai/gpt-4o'
-		),
-		apikey: configString('OpenRouter API key.', ''),
-	},
-	openAICompatible: {
-		endpoint: configString('The endpoint.', 'http://127.0.0.1:11434/v1'),
-		model: configString('The name of the model to use.', 'gpt-4o'),
-		apikey: configString('Your API key.', ''),
-	},
-	azure: {
-		// "void.azure.apiKey": {
-		// 	"type": "string",
-		// 	"description": "Azure API key."
-		// },
-		// "void.azure.deploymentId": {
-		// 	"type": "string",
-		// 	"description": "Azure API deployment ID."
-		// },
-		// "void.azure.resourceName": {
-		// 	"type": "string",
-		// 	"description": "Name of the Azure OpenAI resource. Either this or `baseURL` can be used. \nThe resource name is used in the assembled URL: `https://{resourceName}.openai.azure.com/openai/deployments/{modelId}{path}`"
-		// },
-		// "void.azure.providerSettings": {
-		// 	"type": "object",
-		// 	"properties": {
-		// 		"baseURL": {
-		// 			"type": "string",
-		// 			"default": "https://${resourceName}.openai.azure.com/openai/deployments",
-		// 			"description": "Azure API base URL."
-		// 		},
-		// 		"headers": {
-		// 			"type": "object",
-		// 			"description": "Custom headers to include in the requests."
-		// 		}
-		// 	}
-		// },
-	},
-}
-
-
-// this is the type that comes with metadata like desc, default val, etc
-type VoidConfigInfo = typeof voidConfigInfo
-export type VoidConfigField = keyof typeof voidConfigInfo // typeof configFields[number]
-
-// this is the type that specifies the user's actual config
-export type PartialVoidConfig = {
-	[K in keyof typeof voidConfigInfo]?: {
-		[P in keyof typeof voidConfigInfo[K]]?: typeof voidConfigInfo[K][P]['defaultVal']
-	}
-}
-
-export type VoidConfig = {
-	[K in keyof typeof voidConfigInfo]: {
-		[P in keyof typeof voidConfigInfo[K]]: typeof voidConfigInfo[K][P]['defaultVal']
-	}
-}
-
-
-
-const getVoidConfig = (currentConfig: PartialVoidConfig): VoidConfig => {
-	const config = {} as PartialVoidConfig
-	for (let field of [...configFields, 'default'] as const) {
-		config[field] = {}
-		for (let prop in voidConfigInfo[field]) {
-			config[field][prop] = currentConfig[field]?.[prop] || voidConfigInfo[field][prop].defaultVal
-		}
-	}
-	return config as VoidConfig
-}
-
-const defaultVoidConfig: VoidConfig = getVoidConfig({})
-
-// const [stateRef, setState] = useInstantState(initVal)
-// setState instantly changes the value of stateRef instead of having to wait until the next render
-const useInstantState = <T,>(initVal: T) => {
-	const stateRef = useRef<T>(initVal)
-	const [_, setS] = useState<T>(initVal)
-	const setState = useCallback((newVal: T) => {
-		setS(newVal);
-		stateRef.current = newVal;
-	}, [])
-	return [stateRef as React.RefObject<T>, setState] as const // make s.current readonly - setState handles all changes
-}
-
-
-
-type SetConfigParamType = <K extends VoidConfigField>(field: K, param: keyof VoidConfigInfo[K], newVal: string) => void
-
-type ConfigValueType = {
-	voidConfig: VoidConfig,
-	voidConfigInfo: VoidConfigInfo,
-	partialVoidConfig: PartialVoidConfig,
-	setConfigParam: SetConfigParamType
-}
-
-
-const ConfigContext = createContext<ConfigValueType>(undefined as unknown as ConfigValueType)
-
-export function ConfigProvider({ children }: { children: ReactNode }) {
-	const [partialVoidConfig, setPartialVoidConfig] = useInstantState<PartialVoidConfig>({}) // the user's selections
-	const [voidConfig, setVoidConfig] = useState<VoidConfig>(defaultVoidConfig)
-
-
-	// get the config on mount
-	useEffect(() => {
-		getVSCodeAPI().postMessage({ type: 'getPartialVoidConfig' })
-		awaitVSCodeResponse('partialVoidConfig').then((m) => {
-			setPartialVoidConfig(m.partialVoidConfig)
-			const newFullConfig = getVoidConfig(m.partialVoidConfig)
-			setVoidConfig(newFullConfig)
-		})
-	}, [setPartialVoidConfig])
-
-	// return the provider
-	return (<ConfigContext.Provider
-		value={{
-			voidConfig,
-			voidConfigInfo,
-			partialVoidConfig: partialVoidConfig.current ?? {},
-			setConfigParam: (field, param, newVal) => {
-				const newPartialConfig: PartialVoidConfig = {
-					...partialVoidConfig.current,
-					[field]: {
-						...partialVoidConfig.current?.[field],
-						[param]: newVal
-					}
-				}
-				setPartialVoidConfig(newPartialConfig)
-				const newFullConfig = getVoidConfig(newPartialConfig)
-				setVoidConfig(newFullConfig)
-				getVSCodeAPI().postMessage({ type: 'persistPartialVoidConfig', partialVoidConfig: newPartialConfig })
-			}
-		}}
-	>
-		{children}
-	</ConfigContext.Provider>
-	)
-}
-
-export function useVoidConfig(): ConfigValueType {
-	const context = useContext<ConfigValueType>(ConfigContext)
-	if (context === undefined) {
-		throw new Error("useVoidConfig missing Provider")
-	}
-	return context
-}
-

extensions/void/src/sidebar/contextForThreads.tsx

@@ -1,101 +0,0 @@
-import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
-import { ChatMessage, ChatThreads } from "../shared_types"
-import { awaitVSCodeResponse, getVSCodeAPI } from "./getVscodeApi"
-
-
-// a "thread" means a chat message history
-type ConfigForThreadsValueType = {
-	readonly allThreads: ChatThreads | null,
-	readonly currentThread: ChatThreads[string] | null;
-	addMessageToHistory: (message: ChatMessage) => void;
-	switchToThread: (threadId: string) => void;
-	startNewThread: () => void;
-}
-
-const ThreadsContext = createContext<ConfigForThreadsValueType>(undefined as unknown as ConfigForThreadsValueType)
-
-const createNewThread = () => ({
-	id: new Date().getTime().toString(),
-	createdAt: new Date().toISOString(),
-	messages: [],
-})
-
-
-// const [stateRef, setState] = useInstantState(initVal)
-// setState instantly changes the value of stateRef instead of having to wait until the next render
-const useInstantState = <T,>(initVal: T) => {
-	const stateRef = useRef<T>(initVal)
-	const [_, setS] = useState<T>(initVal)
-	const setState = useCallback((newVal: T) => {
-		setS(newVal);
-		stateRef.current = newVal;
-	}, [])
-	return [stateRef as React.RefObject<T>, setState] as const // make s.current readonly - setState handles all changes
-}
-
-
-export function ThreadsProvider({ children }: { children: ReactNode }) {
-	const [allThreads, setAllThreads] = useInstantState<ChatThreads>({})
-	const [currentThreadId, setCurrentThreadId] = useInstantState<string | null>(null)
-
-	// this loads allThreads in on mount
-	useEffect(() => {
-		getVSCodeAPI().postMessage({ type: 'getAllThreads' })
-		awaitVSCodeResponse('allThreads')
-			.then(response => {
-				setAllThreads(response.threads)
-			})
-	}, [setAllThreads])
-
-
-	return (
-		<ThreadsContext.Provider
-			value={{
-				allThreads: allThreads.current,
-				currentThread: currentThreadId.current === null || allThreads.current === null ? null : allThreads.current[currentThreadId.current],
-				addMessageToHistory: (message: ChatMessage) => {
-					let currentThread: ChatThreads[string]
-					if (!(currentThreadId.current === null || allThreads.current === null)) {
-						currentThread = allThreads.current[currentThreadId.current]
-					}
-					else {
-						currentThread = createNewThread()
-						setCurrentThreadId(currentThread.id)
-					}
-
-					setAllThreads({
-						...allThreads.current,
-						[currentThread.id]: {
-							...currentThread,
-							messages: [...currentThread.messages, message],
-						}
-					})
-
-					getVSCodeAPI().postMessage({ type: "persistThread", thread: currentThread })
-				},
-				switchToThread: (threadId: string) => {
-					setCurrentThreadId(threadId);
-				},
-				startNewThread: () => {
-					const newThread = createNewThread()
-					setAllThreads({
-						...allThreads.current,
-						[newThread.id]: newThread
-					})
-					setCurrentThreadId(newThread.id)
-				},
-			}}
-		>
-			{children}
-		</ThreadsContext.Provider>
-	)
-}
-
-export function useThreads(): ConfigForThreadsValueType {
-	const context = useContext<ConfigForThreadsValueType>(ThreadsContext)
-	if (context === undefined) {
-		throw new Error("useThreads missing Provider")
-	}
-	return context
-}
-

extensions/void/src/sidebar/getVscodeApi.ts

@@ -1,90 +0,0 @@
-import { useEffect } from "react";
-import { MessageFromSidebar, MessageToSidebar, } from "../shared_types";
-import { v4 as uuidv4 } from 'uuid';
-
-
-type Command = MessageToSidebar['type']
-
-// messageType -> res[]
-const onetimeCallbacks: { [C in Command]: ((res: any) => void)[] } = {
-	"ctrl+l": [],
-	"files": [],
-	"partialVoidConfig": [],
-	"startNewThread": [],
-	"allThreads": [],
-	"toggleThreadSelector": [],
-	"toggleSettings": [],
-}
-
-// messageType -> id -> res
-const callbacks: { [C in Command]: { [id: string]: ((res: any) => void) } } = {
-	"ctrl+l": {},
-	"files": {},
-	"partialVoidConfig": {},
-	"startNewThread": {},
-	"allThreads": {},
-	"toggleThreadSelector": {},
-	"toggleSettings": {},
-}
-
-
-// use this function to await responses
-export const awaitVSCodeResponse = <C extends Command>(c: C) => {
-	let result: Promise<MessageToSidebar & { type: C }> = new Promise((res, rej) => {
-		onetimeCallbacks[c].push(res)
-	})
-	return result
-}
-
-
-// use this function to add a listener to a certain type of message
-export const useOnVSCodeMessage = <C extends Command>(messageType: C, fn: (e: MessageToSidebar & { type: C }) => void) => {
-	useEffect(() => {
-		const mType = messageType
-		const callbackId: string = uuidv4();
-		// @ts-ignore
-		callbacks[mType][callbackId] = fn;
-		return () => { delete callbacks[mType][callbackId] }
-	}, [messageType, fn])
-}
-
-
-
-// this function gets called whenever sidebar receives a message - it should only mount once
-export const onMessageFromVSCode = (m: MessageToSidebar) => {
-	// resolve all promises for this message type
-	for (let res of onetimeCallbacks[m.type]) {
-		res(m)
-		onetimeCallbacks[m.type].splice(0) // clear the array
-	}
-	// call the listener for this message type
-	for (let res of Object.values(callbacks[m.type])) {
-		res(m)
-	}
-}
-
-
-
-type AcquireVsCodeApiType = () => {
-	postMessage(message: MessageFromSidebar): void;
-	// setState(state: any): void; // getState and setState are made obsolete by us using { retainContextWhenHidden: true }
-	// getState(): any;
-};
-
-// VS Code exposes the function acquireVsCodeApi() to us, this variable makes sure it only gets called once
-let vsCodeApi: ReturnType<AcquireVsCodeApiType> | undefined;
-
-export function getVSCodeAPI(): ReturnType<AcquireVsCodeApiType> {
-	if (vsCodeApi)
-		return vsCodeApi;
-
-	try {
-		// @ts-expect-error
-		// eslint-disable-next-line no-undef
-		vsCodeApi = acquireVsCodeApi();
-		return vsCodeApi!;
-	} catch (error) {
-		console.error('Failed to acquire VS Code API:', error);
-		throw new Error('This script must be run in a VS Code webview context');
-	}
-}

extensions/void/src/sidebar/index.tsx

@@ -1,23 +0,0 @@
-import * as React from "react"
-import * as ReactDOM from "react-dom/client"
-import Sidebar from "./Sidebar"
-import { ThreadsProvider } from "./contextForThreads"
-import { ConfigProvider } from "./contextForConfig"
-
-// mount the sidebar on the id="root" element
-if (typeof document === "undefined") {
-	console.log("index.tsx error: document was undefined")
-}
-
-const rootElement = document.getElementById("root")!
-console.log("Void root Element:", rootElement)
-
-const extension = (
-	<ThreadsProvider>
-		<ConfigProvider>
-			<Sidebar />
-		</ConfigProvider>
-	</ThreadsProvider>
-)
-const root = ReactDOM.createRoot(rootElement)
-root.render(extension)

extensions/void/src/sidebar/markdown/BlockCode.tsx

@@ -1,100 +0,0 @@
-import React, { ReactNode, useCallback, useEffect, useState } from "react"
-import { getVSCodeAPI } from "../getVscodeApi"
-
-import SyntaxHighlighter from "react-syntax-highlighter";
-import { atomOneDarkReasonable } from "react-syntax-highlighter/dist/esm/styles/hljs";
-
-enum CopyButtonState {
-	Copy = "Copy",
-	Copied = "Copied!",
-	Error = "Could not copy",
-}
-
-const COPY_FEEDBACK_TIMEOUT = 1000
-
-// code block with toolbar (Apply, Copy, etc) at top
-const BlockCode = ({
-	text,
-	language,
-	toolbar,
-	hideToolbar = false,
-	className,
-}: {
-	text: string
-	language?: string
-	toolbar?: ReactNode
-	hideToolbar?: boolean
-	className?: string
-}) => {
-	const [copyButtonState, setCopyButtonState] = useState(CopyButtonState.Copy)
-
-	const customStyle = {
-		...atomOneDarkReasonable,
-		'code[class*="language-"]': {
-			...atomOneDarkReasonable['code[class*="language-"]'],
-			background: "none",
-		},
-	}
-
-	useEffect(() => {
-		if (copyButtonState !== CopyButtonState.Copy) {
-			setTimeout(() => {
-				setCopyButtonState(CopyButtonState.Copy)
-			}, COPY_FEEDBACK_TIMEOUT)
-		}
-	}, [copyButtonState])
-
-	const onCopy = useCallback(() => {
-		navigator.clipboard.writeText(text).then(
-			() => {
-				setCopyButtonState(CopyButtonState.Copied)
-			},
-			() => {
-				setCopyButtonState(CopyButtonState.Error)
-			}
-		)
-	}, [text])
-
-	const defaultToolbar = (
-		<>
-			<button
-				className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
-				onClick={onCopy}
-			>
-				{copyButtonState}
-			</button>
-			<button
-				className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
-				onClick={async () => {
-					getVSCodeAPI().postMessage({ type: "applyChanges", code: text })
-				}}
-			>
-				Apply
-			</button>
-		</>
-	)
-
-	return (
-		<div className="relative group">
-			{!hideToolbar && (
-				<div className="absolute top-0 right-0 invisible group-hover:visible">
-					<div className="flex space-x-2 p-2">{toolbar || defaultToolbar}</div>
-				</div>
-			)}
-			<div
-				className={`overflow-x-auto rounded-sm text-vscode-editor-fg bg-vscode-editor-bg ${!hideToolbar ? "rounded-tl-none" : ""} ${className}`}
-			>
-				<SyntaxHighlighter
-					language={language}
-					style={customStyle}
-					className={"rounded-sm"}
-				>
-					{text}
-				</SyntaxHighlighter>
-
-			</div>
-		</div>
-	)
-}
-
-export default BlockCode

extensions/void/src/test/extension.test.ts

@@ -1,15 +0,0 @@
-import * as assert from 'assert';
-
-// You can import and use all API from the 'vscode' module
-// as well as import your extension to test it
-import * as vscode from 'vscode';
-// import * as myExtension from '../../extension';
-
-suite('Extension Test Suite', () => {
-	vscode.window.showInformationMessage('Start all tests.');
-
-	test('Sample test', () => {
-		assert.strictEqual(-1, [1, 2, 3].indexOf(5));
-		assert.strictEqual(-1, [1, 2, 3].indexOf(0));
-	});
-});

extensions/void/tailwind.config.js

@@ -1,31 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-
-// inject user's vscode theme colors: https://code.visualstudio.com/api/extension-guides/webview#theming-webview-content
-module.exports = {
-	content: ["./src/sidebar/**/*.{html,js,ts,jsx,tsx}"],
-	theme: {
-		extend: {
-			colors: {
-				vscode: {
-					"sidebar-bg": "var(--vscode-sideBar-background)",
-					"editor-bg": "var(--vscode-editor-background)",
-					"editor-fg": "var(--vscode-editor-foreground)",
-					"input-bg": "var(--vscode-input-background)",
-					"input-fg": "var(--vscode-input-foreground)",
-					"input-border": "var(--vscode-input-border)",
-					"button-fg": "var(--vscode-button-foreground)",
-					"button-bg": "var(--vscode-button-background)",
-					"button-hoverBg": "var(--vscode-button-hoverBackground)",
-					"button-secondary-fg": "var(--vscode-button-secondaryForeground)",
-					"button-secondary-bg": "var(--vscode-button-secondaryBackground)",
-					"button-secondary-hoverBg": "var(--vscode-button-secondaryHoverBackground)",
-					"dropdown-bg": "var(--vscode-settings-dropdownBackground)",
-					"dropdown-foreground": "var(--vscode-settings-dropdownForeground)",
-					"dropdown-border": "var(--vscode-settings-dropdownBorder)",
-					"focus-border": "var(--vscode-focusBorder)",
-				},
-			},
-		},
-	},
-	plugins: [],
-};

extensions/void/tsconfig.json

@@ -1,30 +0,0 @@
-{
-	"include": [
-		"src/**/*"
-	],
-	"exclude": [
-		"node_modules"
-	],
-	"compilerOptions": {
-		"jsx": "react",
-		"module": "Node16",
-		"target": "ES6",
-		"outDir": "out",
-		"types": [
-			"node",
-			"mocha",
-		],
-		"lib": [
-			"dom",
-			"es6",
-			"dom.iterable",
-		],
-		"sourceMap": true,
-		"rootDir": "src",
-		"strict": true, /* enable all strict type-checking options */
-		/* Additional Checks */
-		// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
-		// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
-		// "noUnusedParameters": true,  /* Report errors on unused parameters. */
-	}
-}

package.json

@@ -1,14 +1,17 @@
 {
-  "name": "code-oss-dev",
+  "name": "void-dev",
+  "productName": "Void",
   "version": "1.94.0",
-  "distro": "ffcc24343ac46468a625666e5b9e673971dd1a1f",
+  "distro": "this is a commit number if we want to publish on npm",
   "author": {
-    "name": "Microsoft Corporation"
+    "name": "Glass Devtools, Inc."
   },
   "license": "MIT",
   "main": "./out/main",
   "private": true,
   "scripts": {
+    "buildreact": "cd ./src/vs/workbench/contrib/void/browser/react/ && node build.js && cd ../../../../../../../",
+    "watchreact": "cd ./src/vs/workbench/contrib/void/browser/react/ && node build.js --watch && cd ../../../../../../../",
     "test": "echo Please run any of the test scripts from the scripts folder.",
     "test-browser": "npx playwright install && node test/unit/browser/index.js",
     "test-browser-amd": "npx playwright install && node test/unit/browser/index.amd.js",
@@ -72,9 +75,13 @@
     "update-build-ts-version": "npm install typescript@next && tsc -p ./build/tsconfig.build.json"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.32.1",
+    "@google/generative-ai": "^0.21.0",
     "@microsoft/1ds-core-js": "^3.2.13",
     "@microsoft/1ds-post-js": "^3.2.13",
     "@parcel/watcher": "2.1.0",
+    "@rrweb/record": "^2.0.0-alpha.17",
+    "@rrweb/types": "^2.0.0-alpha.17",
     "@vscode/deviceid": "^0.1.1",
     "@vscode/iconv-lite-umd": "0.7.0",
     "@vscode/policy-watcher": "^1.1.4",
@@ -85,6 +92,7 @@
     "@vscode/sudo-prompt": "9.3.1",
     "@vscode/tree-sitter-wasm": "^0.0.4",
     "@vscode/vscode-languagedetection": "1.0.21",
+    "@vscode/webview-ui-toolkit": "^1.4.0",
     "@vscode/windows-mutex": "^0.5.0",
     "@vscode/windows-process-tree": "^0.6.0",
     "@vscode/windows-registry": "^1.1.0",
@@ -96,16 +104,26 @@
     "@xterm/addon-webgl": "^0.19.0-beta.64",
     "@xterm/headless": "^5.6.0-beta.64",
     "@xterm/xterm": "^5.6.0-beta.64",
+    "ajv": "^8.17.1",
+    "diff": "^7.0.0",
+    "groq-sdk": "^0.9.0",
     "http-proxy-agent": "^7.0.0",
     "https-proxy-agent": "^7.0.2",
     "jschardet": "3.1.3",
     "kerberos": "2.1.1",
+    "lucide-react": "^0.460.0",
     "minimist": "^1.2.6",
     "native-is-elevated": "0.7.0",
     "native-keymap": "^3.3.5",
     "native-watchdog": "^1.4.1",
     "node-pty": "1.1.0-beta21",
+    "ollama": "^0.5.11",
     "open": "^8.4.2",
+    "openai": "^4.76.1",
+    "posthog-node": "^4.3.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-syntax-highlighter": "^15.6.1",
     "tas-client-umd": "0.2.0",
     "v8-inspect-profiler": "^0.1.1",
     "vscode-oniguruma": "1.7.0",
@@ -119,12 +137,17 @@
     "@swc/core": "1.3.62",
     "@types/cookie": "^0.3.3",
     "@types/debug": "^4.1.5",
+    "@types/diff": "^6.0.0",
+    "@types/eslint": "^9.6.1",
     "@types/gulp-svgmin": "^1.2.1",
     "@types/http-proxy-agent": "^2.0.1",
     "@types/kerberos": "^1.1.2",
     "@types/minimist": "^1.2.1",
     "@types/mocha": "^9.1.1",
     "@types/node": "20.x",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@types/react-syntax-highlighter": "^15.5.13",
     "@types/sinon": "^10.0.2",
     "@types/sinon-test": "^2.4.2",
     "@types/trusted-types": "^1.0.6",
@@ -190,6 +213,7 @@
     "istanbul-lib-source-maps": "^4.0.1",
     "istanbul-reports": "^3.1.5",
     "lazy.js": "^0.4.2",
+    "marked": "^15.0.0",
     "merge-options": "^1.0.1",
     "mime": "^1.4.1",
     "minimatch": "^3.0.4",
@@ -197,6 +221,7 @@
     "mocha": "^10.2.0",
     "mocha-junit-reporter": "^2.2.1",
     "mocha-multi-reporters": "^1.5.1",
+    "nodemon": "^3.1.9",
     "npm-run-all": "^4.1.5",
     "opn": "^6.0.0",
     "original-fs": "^1.2.0",
@@ -207,16 +232,19 @@
     "postcss-nesting": "^12.0.2",
     "pump": "^1.0.1",
     "rcedit": "^1.1.0",
-    "rimraf": "^2.2.8",
+    "rimraf": "^2.7.1",
+    "scope-tailwind": "^1.0.5",
     "sinon": "^12.0.1",
     "sinon-test": "^3.1.3",
     "source-map": "0.6.1",
     "source-map-support": "^0.3.2",
     "style-loader": "^3.3.2",
+    "tailwindcss": "^3.4.14",
     "ts-loader": "^9.4.2",
     "ts-node": "^10.9.1",
     "tsec": "0.2.7",
     "tslib": "^2.6.3",
+    "tsup": "^8.3.5",
     "typescript": "^5.7.0-dev.20240903",
     "util": "^0.12.4",
     "webpack": "^5.94.0",

product.json

@@ -1,84 +1,38 @@
 {
 	"nameShort": "Void",
 	"nameLong": "Void",
-	"applicationName": "code-oss",
-	"dataFolderName": ".vscode-oss",
-	"win32MutexName": "vscodeoss",
+	"applicationName": "void",
+	"dataFolderName": ".void-editor",
+	"win32MutexName": "voideditor",
 	"licenseName": "MIT",
-	"licenseUrl": "https://github.com/microsoft/vscode/blob/main/LICENSE.txt",
-	"serverLicenseUrl": "https://github.com/microsoft/vscode/blob/main/LICENSE.txt",
+	"licenseUrl": "https://github.com/voideditor/void/blob/main/LICENSE.txt",
+	"serverLicenseUrl": "https://github.com/voideditor/void/blob/main/LICENSE.txt",
 	"serverGreeting": [],
 	"serverLicense": [],
 	"serverLicensePrompt": "",
-	"serverApplicationName": "code-server-oss",
-	"serverDataFolderName": ".vscode-server-oss",
-	"tunnelApplicationName": "code-tunnel-oss",
-	"win32DirName": "Microsoft Code OSS",
-	"win32NameVersion": "Microsoft Code OSS",
-	"win32RegValueName": "CodeOSS",
-	"win32x64AppId": "{{D77B7E06-80BA-4137-BCF4-654B95CCEBC5}",
-	"win32arm64AppId": "{{D1ACE434-89C5-48D1-88D3-E2991DF85475}",
-	"win32x64UserAppId": "{{CC6B787D-37A0-49E8-AE24-8559A032BE0C}",
-	"win32arm64UserAppId": "{{3AEBF0C8-F733-4AD4-BADE-FDB816D53D7B}",
-	"win32AppUserModelId": "Microsoft.CodeOSS",
-	"win32ShellNameShort": "C&ode - OSS",
-	"win32TunnelServiceMutex": "vscodeoss-tunnelservice",
-	"win32TunnelMutex": "vscodeoss-tunnel",
-	"darwinBundleIdentifier": "com.visualstudio.code.oss",
-	"linuxIconName": "code-oss",
+	"serverApplicationName": "void-server",
+	"serverDataFolderName": ".void-server",
+	"tunnelApplicationName": "void-tunnel",
+	"win32DirName": "Void",
+	"win32NameVersion": "Void",
+	"win32RegValueName": "VoidEditor",
+	"win32x64AppId": "{{9D394D01-1728-45A7-B997-A6C82C5452C3}",
+	"win32arm64AppId": "{{0668DD58-2BDE-4101-8CDA-40252DF8875D}",
+	"win32x64UserAppId": "{{8BED5DC1-6C55-46E6-9FE6-18F7E6F7C7F1}",
+	"win32arm64UserAppId": "{{F6C87466-BC82-4A8F-B0FF-18CA366BA4D8}",
+	"win32AppUserModelId": "Void.Editor",
+	"win32ShellNameShort": "V&oid",
+	"win32TunnelServiceMutex": "void-tunnelservice",
+	"win32TunnelMutex": "void-tunnel",
+	"darwinBundleIdentifier": "com.voideditor.code",
+	"linuxIconName": "void-editor",
 	"licenseFileName": "LICENSE.txt",
-	"reportIssueUrl": "https://github.com/microsoft/vscode/issues/new",
+	"reportIssueUrl": "https://github.com/voideditor/void/issues/new",
 	"nodejsRepository": "https://nodejs.org",
-	"urlProtocol": "code-oss",
-	"webviewContentExternalBaseUrlTemplate": "https://{{uuid}}.vscode-cdn.net/insider/ef65ac1ba57f57f2a3961bfe94aa20481caca4c6/out/vs/workbench/contrib/webview/browser/pre/",
-	"builtInExtensions": [
-		{
-			"name": "ms-vscode.js-debug-companion",
-			"version": "1.1.3",
-			"sha256": "7380a890787452f14b2db7835dfa94de538caf358ebc263f9d46dd68ac52de93",
-			"repo": "https://github.com/microsoft/vscode-js-debug-companion",
-			"metadata": {
-				"id": "99cb0b7f-7354-4278-b8da-6cc79972169d",
-				"publisherId": {
-					"publisherId": "5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee",
-					"publisherName": "ms-vscode",
-					"displayName": "Microsoft",
-					"flags": "verified"
-				},
-				"publisherDisplayName": "Microsoft"
-			}
-		},
-		{
-			"name": "ms-vscode.js-debug",
-			"version": "1.93.0",
-			"sha256": "9339cb8e6b77f554df54d79e71f533279cb76b0f9b04c207f633bfd507442b6a",
-			"repo": "https://github.com/microsoft/vscode-js-debug",
-			"metadata": {
-				"id": "25629058-ddac-4e17-abba-74678e126c5d",
-				"publisherId": {
-					"publisherId": "5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee",
-					"publisherName": "ms-vscode",
-					"displayName": "Microsoft",
-					"flags": "verified"
-				},
-				"publisherDisplayName": "Microsoft"
-			}
-		},
-		{
-			"name": "ms-vscode.vscode-js-profile-table",
-			"version": "1.0.9",
-			"sha256": "3b62ee4276a2bbea3fe230f94b1d5edd915b05966090ea56f882e1e0ab53e1a6",
-			"repo": "https://github.com/microsoft/vscode-js-profile-visualizer",
-			"metadata": {
-				"id": "7e52b41b-71ad-457b-ab7e-0620f1fc4feb",
-				"publisherId": {
-					"publisherId": "5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee",
-					"publisherName": "ms-vscode",
-					"displayName": "Microsoft",
-					"flags": "verified"
-				},
-				"publisherDisplayName": "Microsoft"
-			}
-		}
-	]
+	"urlProtocol": "void-editor",
+	"extensionsGallery": {
+		"serviceUrl": "https://open-vsx.org/vscode/gallery",
+		"itemUrl": "https://open-vsx.org/vscode/item"
+	},
+	"builtInExtensions": []
 }

src/main.js

@@ -123,7 +123,7 @@ protocol.registerSchemesAsPrivileged([
 	},
 	{
 		scheme: 'vscode-file',
-		privileges: { secure: true, standard: true, supportFetchAPI: true, corsEnabled: true, codeCache: true }
+		privileges: { secure: true, standard: true, supportFetchAPI: true, corsEnabled: true, codeCache: true, }
 	}
 ]);
 

src/tsconfig.json

@@ -1,6 +1,7 @@
 {
 	"extends": "./tsconfig.base.json",
 	"compilerOptions": {
+		// "jsx": "react", // <-- Void added this
 		"esModuleInterop": true,
 		"removeComments": false,
 		"preserveConstEnums": true,
@@ -51,6 +52,10 @@
 		"./typings",
 		"./vs/**/*.ts",
 		"vscode-dts/vscode.proposed.*.d.ts",
-		"vscode-dts/vscode.d.ts"
+		"vscode-dts/vscode.d.ts",
+
+		// Void added these:
+		// "./vs/workbench/contrib/void/browser/**.tsx",
+		// "./vs/**/*.d.mts",
 	]
 }

src/vs/base/browser/ui/inputbox/inputBox.ts

@@ -159,7 +159,7 @@ export class InputBox extends Widget {
 			this.scrollableElement = new ScrollableElement(this.element, { vertical: ScrollbarVisibility.Auto });
 
 			if (this.options.flexibleWidth) {
-				this.input.setAttribute('wrap', 'off');
+				this.input.setAttribute('wrap', 'on');
 				this.mirror.style.whiteSpace = 'pre';
 				this.mirror.style.wordWrap = 'initial';
 			}

src/vs/code/electron-main/app.ts

@@ -121,6 +121,10 @@ import { normalizeNFC } from '../../base/common/normalization.js';
 import { ICSSDevelopmentService, CSSDevelopmentService } from '../../platform/cssDev/node/cssDevService.js';
 import { ExtensionSignatureVerificationService, IExtensionSignatureVerificationService } from '../../platform/extensionManagement/node/extensionSignatureVerificationService.js';
 
+import { LLMMessageChannel } from '../../platform/void/electron-main/llmMessageChannel.js';
+import { IMetricsService } from '../../platform/void/common/metricsService.js';
+import { MetricsMainService } from '../../platform/void/electron-main/metricsMainService.js';
+
 /**
  * The main VS Code application. There will only ever be one instance,
  * even if the user starts many instances (e.g. from the command line).
@@ -148,7 +152,7 @@ export class CodeApplication extends Disposable {
 		@IStateService private readonly stateService: IStateService,
 		@IFileService private readonly fileService: IFileService,
 		@IProductService private readonly productService: IProductService,
-		@IUserDataProfilesMainService private readonly userDataProfilesMainService: IUserDataProfilesMainService
+		@IUserDataProfilesMainService private readonly userDataProfilesMainService: IUserDataProfilesMainService,
 	) {
 		super();
 
@@ -508,6 +512,16 @@ export class CodeApplication extends Disposable {
 		});
 
 		//#endregion
+
+		// //#region Void IPC
+		// validatedIpcMain.handle('vscode:sendLLMMessage', async (event, data) => {
+		// 	try {
+		// 		await this.sendLLMMessage(data);
+		// 	} catch (error) {
+		// 		console.error('Error sending LLM message:', error);
+		// 	}
+		// });
+		// //#endregion
 	}
 
 	private onUnexpectedError(error: Error): void {
@@ -1091,6 +1105,9 @@ export class CodeApplication extends Disposable {
 			services.set(ITelemetryService, NullTelemetryService);
 		}
 
+		// Void main process services (required for services with a channel for comm between browser and electron-main (node))
+		services.set(IMetricsService, new SyncDescriptor(MetricsMainService, undefined, false));
+
 		// Default Extensions Profile Init
 		services.set(IExtensionsProfileScannerService, new SyncDescriptor(ExtensionsProfileScannerService, undefined, true));
 		services.set(IExtensionsScannerService, new SyncDescriptor(ExtensionsScannerService, undefined, true));
@@ -1225,6 +1242,12 @@ export class CodeApplication extends Disposable {
 		mainProcessElectronServer.registerChannel('logger', loggerChannel);
 		sharedProcessClient.then(client => client.registerChannel('logger', loggerChannel));
 
+		// Void - use loggerChannel as reference
+		const metricsChannel = ProxyChannel.fromService(accessor.get(IMetricsService), disposables);
+		mainProcessElectronServer.registerChannel('void-channel-metrics', metricsChannel);
+		const llmMessageChannel = new LLMMessageChannel(accessor.get(IMetricsService));
+		mainProcessElectronServer.registerChannel('void-channel-llmMessageService', llmMessageChannel);
+
 		// Extension Host Debug Broadcasting
 		const electronExtensionHostDebugBroadcastChannel = new ElectronExtensionHostDebugBroadcastChannel(accessor.get(IWindowsMainService));
 		mainProcessElectronServer.registerChannel('extensionhostdebugservice', electronExtensionHostDebugBroadcastChannel);

src/vs/editor/browser/services/codeEditorService.ts

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+
 import { Event } from '../../../base/common/event.js';
 import { ICodeEditor, IDiffEditor } from '../editorBrowser.js';
 import { IDecorationRenderOptions } from '../../common/editorCommon.js';

src/vs/editor/browser/services/inlineDiffService/inlineDiffService.ts

@@ -0,0 +1,135 @@
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IModelDeltaDecoration } from '../../../common/model.js';
+import { ICodeEditor, IViewZone } from '../../editorBrowser.js';
+import { IRange } from '../../../common/core/range.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
+
+
+// THIS FILE IS OLD + UNUSED!!!
+
+// SEE inlineDiffsService.ts INSTEAD.
+
+export interface IInlineDiffService {
+	readonly _serviceBrand: undefined;
+	addDiff(editor: ICodeEditor, originalText: string, modifiedRange: IRange): void;
+	removeDiffs(editor: ICodeEditor): void;
+}
+
+export const IInlineDiffService = createDecorator<IInlineDiffService>('inlineDiffServiceOld');
+
+class InlineDiffService extends Disposable implements IInlineDiffService {
+	private readonly _diffDecorations = new Map<ICodeEditor, string[]>();
+	private readonly _diffZones = new Map<ICodeEditor, string[]>();
+	_serviceBrand: undefined;
+
+	constructor() {
+		super();
+	}
+
+	initStream() {
+
+
+	}
+
+
+	public addDiff: IInlineDiffService['addDiff'] = (editor, originalText, modifiedRange) => {
+		// Clear existing diffs
+		this.removeDiffs(editor);
+
+		// green decoration and gutter decoration
+		const greenDecoration: IModelDeltaDecoration[] = [{
+			range: modifiedRange,
+			options: {
+				className: 'line-insert', // .monaco-editor .line-insert
+				description: 'line-insert',
+				isWholeLine: true,
+				minimap: {
+					color: { id: 'minimapGutter.addedBackground' },
+					position: 2
+				},
+				overviewRuler: {
+					color: { id: 'editorOverviewRuler.addedForeground' },
+					position: 7
+				}
+			}
+		}];
+
+		this._diffDecorations.set(editor, editor.deltaDecorations([], greenDecoration));
+
+		// red in a view zone
+		editor.changeViewZones(accessor => {
+			// Get the editor's font info
+			const fontInfo = editor.getOption(EditorOption.fontInfo);
+
+			const domNode = document.createElement('div');
+			// domNode.className = 'monaco-editor view-zones line-delete monaco-mouse-cursor-text';
+			domNode.style.fontSize = `${fontInfo.fontSize}px`;
+			domNode.style.fontFamily = fontInfo.fontFamily;
+			domNode.style.lineHeight = `${fontInfo.lineHeight}px`;
+
+			// div
+			const lineContent = document.createElement('div');
+			// lineContent.className = 'view-line'; // .monaco-editor .inline-deleted-text
+
+			// span
+			const contentSpan = document.createElement('span');
+
+			// span
+			const codeSpan = document.createElement('span');
+			// codeSpan.className = 'mtk1'; // char-delete
+			codeSpan.textContent = originalText;
+
+			// Mount
+			contentSpan.appendChild(codeSpan);
+			lineContent.appendChild(contentSpan);
+			domNode.appendChild(lineContent);
+
+			const viewZone: IViewZone = {
+				afterLineNumber: modifiedRange.startLineNumber - 1,
+				heightInLines: originalText.split('\n').length + 1,
+				domNode: domNode,
+				suppressMouseDown: true,
+				marginDomNode: this.createGutterElement()
+			};
+
+			const zoneId = accessor.addZone(viewZone);
+			// editor.layout();
+			this._diffZones.set(editor, [zoneId]);
+		});
+	}
+
+	//  gutter is the thing to the left
+	private createGutterElement(): HTMLElement {
+		const gutterDiv = document.createElement('div');
+		gutterDiv.className = 'inline-diff-gutter';
+
+		const minusDiv = document.createElement('div');
+		minusDiv.className = 'inline-diff-deleted-gutter';
+		// minusDiv.textContent = '-';
+
+		gutterDiv.appendChild(minusDiv);
+		return gutterDiv;
+	}
+
+	public removeDiffs(editor: ICodeEditor): void {
+		const decorationIds = this._diffDecorations.get(editor) || [];
+		editor.deltaDecorations(decorationIds, []);
+		this._diffDecorations.delete(editor);
+
+		editor.changeViewZones(accessor => {
+			const zoneIds = this._diffZones.get(editor) || [];
+			zoneIds.forEach(id => accessor.removeZone(id));
+		});
+		this._diffZones.delete(editor);
+	}
+
+	override dispose(): void {
+		super.dispose();
+		this._diffDecorations.clear();
+		this._diffZones.clear();
+	}
+}
+
+registerSingleton(IInlineDiffService, InlineDiffService, InstantiationType.Eager);

src/vs/editor/browser/widget/diffEditor/style.css

@@ -425,3 +425,5 @@
 		margin: 0 4px;
 	}
 }
+
+

src/vs/editor/contrib/lineSelection/browser/lineSelection.ts

@@ -22,7 +22,7 @@ export class ExpandLineSelectionAction extends EditorAction {
 			kbOpts: {
 				weight: KeybindingWeight.EditorCore,
 				kbExpr: EditorContextKeys.textInputFocus,
-				primary: KeyMod.CtrlCmd | KeyCode.KeyL
+				primary: KeyMod.CtrlCmd | KeyCode.KeyM // Void changed this to Cmd+M
 			},
 		});
 	}

src/vs/platform/update/electron-main/abstractUpdateService.ts

@@ -15,6 +15,7 @@ import { IRequestService } from '../../request/common/request.js';
 import { AvailableForDownload, DisablementReason, IUpdateService, State, StateType, UpdateType } from '../common/update.js';
 
 export function createUpdateURL(platform: string, quality: string, productService: IProductService): string {
+	// return `https://voideditor.dev/api/update/${platform}/stable`;
 	return `${productService.updateUrl}/api/update/${platform}/${quality}/${productService.commit}`;
 }
 
@@ -70,9 +71,11 @@ export abstract class AbstractUpdateService implements IUpdateService {
 	 */
 	protected async initialize(): Promise<void> {
 		if (!this.environmentMainService.isBuilt) {
+			console.log('is NOT built, canceling update service')
 			this.setState(State.Disabled(DisablementReason.NotBuilt));
 			return; // updates are never enabled when running out of sources
 		}
+		console.log('is built, continuing with update service')
 
 		if (this.environmentMainService.disableUpdates) {
 			this.setState(State.Disabled(DisablementReason.DisabledByEnvironment));
@@ -86,16 +89,19 @@ export abstract class AbstractUpdateService implements IUpdateService {
 			return;
 		}
 
-		const updateMode = this.configurationService.getValue<'none' | 'manual' | 'start' | 'default'>('update.mode');
-		const quality = this.getProductQuality(updateMode);
+		// Void - for now, always update
 
+		const updateMode = this.configurationService.getValue<'none' | 'manual' | 'start' | 'default'>('update.mode');
+
+		const quality = this.getProductQuality(updateMode);
 		if (!quality) {
 			this.setState(State.Disabled(DisablementReason.ManuallyDisabled));
 			this.logService.info('update#ctor - updates are disabled by user preference');
 			return;
 		}
 
-		this.url = this.buildUpdateFeedUrl(quality);
+		// const quality = 'stable'
+		this.url = this.doBuildUpdateFeedUrl(quality);
 		if (!this.url) {
 			this.setState(State.Disabled(DisablementReason.InvalidConfiguration));
 			this.logService.info('update#ctor - updates are disabled as the update URL is badly formed');
@@ -131,13 +137,10 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		return updateMode === 'none' ? undefined : this.productService.quality;
 	}
 
-	private scheduleCheckForUpdates(delay = 60 * 60 * 1000): Promise<void> {
-		return timeout(delay)
-			.then(() => this.checkForUpdates(false))
-			.then(() => {
-				// Check again after 1 hour
-				return this.scheduleCheckForUpdates(60 * 60 * 1000);
-			});
+	private async scheduleCheckForUpdates(delay = 60 * 60 * 1000): Promise<void> {
+		await timeout(delay);
+		await this.checkForUpdates(false);
+		return await this.scheduleCheckForUpdates(60 * 60 * 1000);
 	}
 
 	async checkForUpdates(explicit: boolean): Promise<void> {
@@ -160,6 +163,7 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		await this.doDownloadUpdate(this.state);
 	}
 
+	// override implemented by windows and linux
 	protected async doDownloadUpdate(state: AvailableForDownload): Promise<void> {
 		// noop
 	}
@@ -174,6 +178,7 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		await this.doApplyUpdate();
 	}
 
+	// windows overrides this
 	protected async doApplyUpdate(): Promise<void> {
 		// noop
 	}
@@ -236,6 +241,6 @@ export abstract class AbstractUpdateService implements IUpdateService {
 		// noop
 	}
 
-	protected abstract buildUpdateFeedUrl(quality: string): string | undefined;
+	protected abstract doBuildUpdateFeedUrl(quality: string): string | undefined;
 	protected abstract doCheckForUpdates(context: any): void;
 }

src/vs/platform/update/electron-main/updateService.darwin.ts

@@ -73,7 +73,7 @@ export class DarwinUpdateService extends AbstractUpdateService implements IRelau
 		this.setState(State.Idle(UpdateType.Archive, message));
 	}
 
-	protected buildUpdateFeedUrl(quality: string): string | undefined {
+	protected doBuildUpdateFeedUrl(quality: string): string | undefined {
 		let assetID: string;
 		if (!this.productService.darwinUniversalAssetId) {
 			assetID = process.arch === 'x64' ? 'darwin' : 'darwin-arm64';

src/vs/platform/update/electron-main/updateService.linux.ts

@@ -30,7 +30,7 @@ export class LinuxUpdateService extends AbstractUpdateService {
 		super(lifecycleMainService, configurationService, environmentMainService, requestService, logService, productService);
 	}
 
-	protected buildUpdateFeedUrl(quality: string): string {
+	protected doBuildUpdateFeedUrl(quality: string): string {
 		return createUpdateURL(`linux-${process.arch}`, quality, this.productService);
 	}
 

src/vs/platform/update/electron-main/updateService.win32.ts

@@ -99,7 +99,7 @@ export class Win32UpdateService extends AbstractUpdateService implements IRelaun
 		await super.initialize();
 	}
 
-	protected buildUpdateFeedUrl(quality: string): string | undefined {
+	protected doBuildUpdateFeedUrl(quality: string): string | undefined {
 		let platform = `win32-${process.arch}`;
 
 		if (getUpdateType() === UpdateType.Archive) {

src/vs/platform/void/browser/void.contribution.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+// ---------- common ----------
+
+// llmMessage
+import '../common/llmMessageService.js'
+
+// voidSettings
+import '../common/voidSettingsService.js'
+
+// refreshModel
+import '../common/refreshModelService.js'
+
+// metrics
+import '../common/metricsService.js'

src/vs/platform/void/common/llmMessageService.ts

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { EventLLMMessageOnTextParams, EventLLMMessageOnErrorParams, EventLLMMessageOnFinalMessageParams, ServiceSendLLMMessageParams, MainLLMMessageParams, MainLLMMessageAbortParams, ServiceModelListParams, EventModelListOnSuccessParams, EventModelListOnErrorParams, MainModelListParams, OllamaModelResponse, OpenaiCompatibleModelResponse, } from './llmMessageTypes.js';
+import { IChannel } from '../../../base/parts/ipc/common/ipc.js';
+import { IMainProcessService } from '../../ipc/common/mainProcessService.js';
+import { InstantiationType, registerSingleton } from '../../instantiation/common/extensions.js';
+import { generateUuid } from '../../../base/common/uuid.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { Event } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { IVoidSettingsService } from './voidSettingsService.js';
+// import { INotificationService } from '../../notification/common/notification.js';
+
+// calls channel to implement features
+export const ILLMMessageService = createDecorator<ILLMMessageService>('llmMessageService');
+
+export interface ILLMMessageService {
+	readonly _serviceBrand: undefined;
+	sendLLMMessage: (params: ServiceSendLLMMessageParams) => string | null;
+	abort: (requestId: string) => void;
+	ollamaList: (params: ServiceModelListParams<OllamaModelResponse>) => void;
+	openAICompatibleList: (params: ServiceModelListParams<OpenaiCompatibleModelResponse>) => void;
+}
+
+export class LLMMessageService extends Disposable implements ILLMMessageService {
+
+	readonly _serviceBrand: undefined;
+	private readonly channel: IChannel // LLMMessageChannel
+
+	// llmMessage
+	private readonly onTextHooks_llm: { [eventId: string]: ((params: EventLLMMessageOnTextParams) => void) } = {}
+	private readonly onFinalMessageHooks_llm: { [eventId: string]: ((params: EventLLMMessageOnFinalMessageParams) => void) } = {}
+	private readonly onErrorHooks_llm: { [eventId: string]: ((params: EventLLMMessageOnErrorParams) => void) } = {}
+
+
+	// ollamaList
+	private readonly onSuccess_ollama: { [eventId: string]: ((params: EventModelListOnSuccessParams<OllamaModelResponse>) => void) } = {}
+	private readonly onError_ollama: { [eventId: string]: ((params: EventModelListOnErrorParams<OllamaModelResponse>) => void) } = {}
+
+	// openAICompatibleList
+	private readonly onSuccess_openAICompatible: { [eventId: string]: ((params: EventModelListOnSuccessParams<OpenaiCompatibleModelResponse>) => void) } = {}
+	private readonly onError_openAICompatible: { [eventId: string]: ((params: EventModelListOnErrorParams<OpenaiCompatibleModelResponse>) => void) } = {}
+
+	constructor(
+		@IMainProcessService private readonly mainProcessService: IMainProcessService, // used as a renderer (only usable on client side)
+		@IVoidSettingsService private readonly voidSettingsService: IVoidSettingsService,
+		// @INotificationService private readonly notificationService: INotificationService,
+	) {
+		super()
+
+		// const service = ProxyChannel.toService<LLMMessageChannel>(mainProcessService.getChannel('void-channel-sendLLMMessage')); // lets you call it like a service
+		this.channel = this.mainProcessService.getChannel('void-channel-llmMessageService')
+
+		// .listen sets up an IPC channel and takes a few ms, so we set up listeners immediately and add hooks to them instead
+		// llm
+		this._register((this.channel.listen('onText_llm') satisfies Event<EventLLMMessageOnTextParams>)(e => {
+			this.onTextHooks_llm[e.requestId]?.(e)
+		}))
+		this._register((this.channel.listen('onFinalMessage_llm') satisfies Event<EventLLMMessageOnFinalMessageParams>)(e => {
+			this.onFinalMessageHooks_llm[e.requestId]?.(e)
+			this._onRequestIdDone(e.requestId)
+		}))
+		this._register((this.channel.listen('onError_llm') satisfies Event<EventLLMMessageOnErrorParams>)(e => {
+			console.log('Error in LLMMessageService:', JSON.stringify(e))
+			this.onErrorHooks_llm[e.requestId]?.(e)
+			this._onRequestIdDone(e.requestId)
+		}))
+		// ollama
+		this._register((this.channel.listen('onSuccess_ollama') satisfies Event<EventModelListOnSuccessParams<OllamaModelResponse>>)(e => {
+			this.onSuccess_ollama[e.requestId]?.(e)
+		}))
+		this._register((this.channel.listen('onError_ollama') satisfies Event<EventModelListOnErrorParams<OllamaModelResponse>>)(e => {
+			this.onError_ollama[e.requestId]?.(e)
+		}))
+		// openaiCompatible
+		this._register((this.channel.listen('onSuccess_openAICompatible') satisfies Event<EventModelListOnSuccessParams<OpenaiCompatibleModelResponse>>)(e => {
+			this.onSuccess_openAICompatible[e.requestId]?.(e)
+		}))
+		this._register((this.channel.listen('onError_openAICompatible') satisfies Event<EventModelListOnErrorParams<OpenaiCompatibleModelResponse>>)(e => {
+			this.onError_openAICompatible[e.requestId]?.(e)
+		}))
+
+	}
+
+	sendLLMMessage(params: ServiceSendLLMMessageParams) {
+		const { onText, onFinalMessage, onError, ...proxyParams } = params;
+		const { featureName } = proxyParams
+
+		// end early if no provider
+		const modelSelection = this.voidSettingsService.state.modelSelectionOfFeature[featureName]
+		if (modelSelection === null) {
+			onError({ message: 'Please add a Provider in Settings!', fullError: null })
+			return null
+		}
+		const { providerName, modelName } = modelSelection
+
+		// add state for request id
+		const requestId_ = generateUuid();
+		this.onTextHooks_llm[requestId_] = onText
+		this.onFinalMessageHooks_llm[requestId_] = onFinalMessage
+		this.onErrorHooks_llm[requestId_] = onError
+
+		const { settingsOfProvider } = this.voidSettingsService.state
+
+		// params will be stripped of all its functions over the IPC channel
+		this.channel.call('sendLLMMessage', {
+			...proxyParams,
+			requestId: requestId_,
+			providerName,
+			modelName,
+			settingsOfProvider,
+		} satisfies MainLLMMessageParams);
+
+		return requestId_
+	}
+
+
+	abort(requestId: string) {
+		this.channel.call('abort', { requestId } satisfies MainLLMMessageAbortParams);
+		this._onRequestIdDone(requestId)
+	}
+
+
+	ollamaList = (params: ServiceModelListParams<OllamaModelResponse>) => {
+		const { onSuccess, onError, ...proxyParams } = params
+
+		const { settingsOfProvider } = this.voidSettingsService.state
+
+		// add state for request id
+		const requestId_ = generateUuid();
+		this.onSuccess_ollama[requestId_] = onSuccess
+		this.onError_ollama[requestId_] = onError
+
+		this.channel.call('ollamaList', {
+			...proxyParams,
+			settingsOfProvider,
+			requestId: requestId_,
+		} satisfies MainModelListParams<OllamaModelResponse>)
+	}
+
+	openAICompatibleList = (params: ServiceModelListParams<OpenaiCompatibleModelResponse>) => {
+		const { onSuccess, onError, ...proxyParams } = params
+
+		const { settingsOfProvider } = this.voidSettingsService.state
+
+		// add state for request id
+		const requestId_ = generateUuid();
+		this.onSuccess_openAICompatible[requestId_] = onSuccess
+		this.onError_openAICompatible[requestId_] = onError
+
+		this.channel.call('openAICompatibleList', {
+			...proxyParams,
+			settingsOfProvider,
+			requestId: requestId_,
+		} satisfies MainModelListParams<OpenaiCompatibleModelResponse>)
+	}
+
+
+
+	_onRequestIdDone(requestId: string) {
+		delete this.onTextHooks_llm[requestId]
+		delete this.onFinalMessageHooks_llm[requestId]
+		delete this.onErrorHooks_llm[requestId]
+
+		delete this.onSuccess_ollama[requestId]
+		delete this.onError_ollama[requestId]
+	}
+}
+
+registerSingleton(ILLMMessageService, LLMMessageService, InstantiationType.Eager);
+

src/vs/platform/void/common/llmMessageTypes.ts

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IRange } from '../../../editor/common/core/range'
+import { ProviderName, SettingsOfProvider } from './voidSettingsTypes.js'
+
+
+export type OnText = (p: { newText: string, fullText: string }) => void
+export type OnFinalMessage = (p: { fullText: string }) => void
+export type OnError = (p: { message: string, fullError: Error | null }) => void
+export type AbortRef = { current: (() => void) | null }
+
+export type LLMMessage = {
+	role: 'system' | 'user' | 'assistant';
+	content: string;
+}
+
+export type ServiceSendLLMFeatureParams = {
+	featureName: 'Ctrl+K';
+	range: IRange;
+} | {
+	featureName: 'Ctrl+L';
+} | {
+	featureName: 'Autocomplete';
+	range: IRange;
+}
+
+// params to the true sendLLMMessage function
+export type LLMMMessageParams = {
+	onText: OnText;
+	onFinalMessage: OnFinalMessage;
+	onError: OnError;
+	abortRef: AbortRef;
+
+	messages: LLMMessage[];
+
+	logging: {
+		loggingName: string,
+	};
+	providerName: ProviderName;
+	modelName: string;
+	settingsOfProvider: SettingsOfProvider;
+}
+
+export type ServiceSendLLMMessageParams = {
+	onText: OnText;
+	onFinalMessage: OnFinalMessage;
+	onError: OnError;
+
+	messages: LLMMessage[];
+
+	logging: {
+		loggingName: string,
+	};
+} & ServiceSendLLMFeatureParams
+
+// can't send functions across a proxy, use listeners instead
+export type BlockedMainLLMMessageParams = 'onText' | 'onFinalMessage' | 'onError' | 'abortRef'
+
+export type MainLLMMessageParams = Omit<LLMMMessageParams, BlockedMainLLMMessageParams> & { requestId: string }
+export type MainLLMMessageAbortParams = { requestId: string }
+
+export type EventLLMMessageOnTextParams = Parameters<OnText>[0] & { requestId: string }
+export type EventLLMMessageOnFinalMessageParams = Parameters<OnFinalMessage>[0] & { requestId: string }
+export type EventLLMMessageOnErrorParams = Parameters<OnError>[0] & { requestId: string }
+
+export type _InternalSendLLMMessageFnType = (params: {
+	messages: LLMMessage[];
+	onText: OnText;
+	onFinalMessage: OnFinalMessage;
+	onError: OnError;
+	settingsOfProvider: SettingsOfProvider;
+	providerName: ProviderName;
+	modelName: string;
+
+	_setAborter: (aborter: () => void) => void;
+}) => void
+
+// service -> main -> internal -> event (back to main)
+// (browser)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// These are from 'ollama' SDK
+interface OllamaModelDetails {
+	parent_model: string;
+	format: string;
+	family: string;
+	families: string[];
+	parameter_size: string;
+	quantization_level: string;
+}
+
+export type OllamaModelResponse = {
+	name: string;
+	modified_at: Date;
+	size: number;
+	digest: string;
+	details: OllamaModelDetails;
+	expires_at: Date;
+	size_vram: number;
+}
+
+export type OpenaiCompatibleModelResponse = {
+	id: string;
+	created: number;
+	object: 'model';
+	owned_by: string;
+}
+
+
+// params to the true list fn
+export type ModelListParams<modelResponse> = {
+	settingsOfProvider: SettingsOfProvider;
+	onSuccess: (param: { models: modelResponse[] }) => void;
+	onError: (param: { error: string }) => void;
+}
+
+// params to the service
+export type ServiceModelListParams<modelResponse> = {
+	onSuccess: (param: { models: modelResponse[] }) => void;
+	onError: (param: { error: any }) => void;
+}
+
+type BlockedMainModelListParams = 'onSuccess' | 'onError'
+export type MainModelListParams<modelResponse> = Omit<ModelListParams<modelResponse>, BlockedMainModelListParams> & { requestId: string }
+
+export type EventModelListOnSuccessParams<modelResponse> = Parameters<ModelListParams<modelResponse>['onSuccess']>[0] & { requestId: string }
+export type EventModelListOnErrorParams<modelResponse> = Parameters<ModelListParams<modelResponse>['onError']>[0] & { requestId: string }
+
+
+
+
+export type _InternalModelListFnType<modelResponse> = (params: ModelListParams<modelResponse>) => void

src/vs/platform/void/common/metricsService.ts

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { ProxyChannel } from '../../../base/parts/ipc/common/ipc.js';
+import { IMainProcessService } from '../../ipc/common/mainProcessService.js';
+import { InstantiationType, registerSingleton } from '../../instantiation/common/extensions.js';
+
+export interface IMetricsService {
+	readonly _serviceBrand: undefined;
+	capture(event: string, params: Record<string, any>): void;
+}
+
+export const IMetricsService = createDecorator<IMetricsService>('metricsService');
+
+
+// implemented by calling channel
+export class MetricsService implements IMetricsService {
+
+	readonly _serviceBrand: undefined;
+	private readonly metricsService: IMetricsService;
+
+	constructor(
+		@IMainProcessService mainProcessService: IMainProcessService // (only usable on client side)
+	) {
+		this.metricsService = ProxyChannel.toService<IMetricsService>(mainProcessService.getChannel('void-channel-metrics'));
+	}
+
+	// call capture on the channel
+	capture(...params: Parameters<IMetricsService['capture']>) {
+		this.metricsService.capture(...params);
+	}
+
+}
+
+registerSingleton(IMetricsService, MetricsService, InstantiationType.Eager);
+

src/vs/platform/void/common/refreshModelService.ts

@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { InstantiationType, registerSingleton } from '../../instantiation/common/extensions.js';
+import { IVoidSettingsService } from './voidSettingsService.js';
+import { ILLMMessageService } from './llmMessageService.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { Disposable, IDisposable } from '../../../base/common/lifecycle.js';
+import { RefreshableProviderName, refreshableProviderNames, SettingsOfProvider } from './voidSettingsTypes.js';
+import { OllamaModelResponse, OpenaiCompatibleModelResponse } from './llmMessageTypes.js';
+
+
+
+
+type RefreshableState = ({
+	state: 'init',
+	timeoutId: null,
+} | {
+	state: 'refreshing',
+	timeoutId: NodeJS.Timeout | null, // the timeoutId of the most recent call to refreshModels
+} | {
+	state: 'finished',
+	timeoutId: null,
+} | {
+	state: 'finished_invisible',
+	timeoutId: null,
+})
+
+
+export type RefreshModelStateOfProvider = Record<RefreshableProviderName, RefreshableState>
+
+
+
+const refreshBasedOn: { [k in RefreshableProviderName]: (keyof SettingsOfProvider[k])[] } = {
+	ollama: ['_enabled', 'endpoint'],
+	openAICompatible: ['_enabled', 'endpoint', 'apiKey'],
+}
+const REFRESH_INTERVAL = 5_000
+// const COOLDOWN_TIMEOUT = 300
+
+// element-wise equals
+function eq<T>(a: T[], b: T[]): boolean {
+	if (a.length !== b.length) return false
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false
+	}
+	return true
+}
+export interface IRefreshModelService {
+	readonly _serviceBrand: undefined;
+	refreshModels: (providerName: RefreshableProviderName) => Promise<void>;
+	onDidChangeState: Event<RefreshableProviderName>;
+	state: RefreshModelStateOfProvider;
+}
+
+export const IRefreshModelService = createDecorator<IRefreshModelService>('RefreshModelService');
+
+export class RefreshModelService extends Disposable implements IRefreshModelService {
+
+	readonly _serviceBrand: undefined;
+
+	private readonly _onDidChangeState = new Emitter<RefreshableProviderName>();
+	readonly onDidChangeState: Event<RefreshableProviderName> = this._onDidChangeState.event; // this is primarily for use in react, so react can listen + update on state changes
+
+
+	constructor(
+		@IVoidSettingsService private readonly voidSettingsService: IVoidSettingsService,
+		@ILLMMessageService private readonly llmMessageService: ILLMMessageService,
+	) {
+		super()
+
+
+		const disposables: Set<IDisposable> = new Set()
+
+		const initializePollingAndOnChange = () => {
+			this._clearAllTimeouts()
+			disposables.forEach(d => d.dispose())
+			disposables.clear()
+
+			if (!voidSettingsService.state.featureFlagSettings.autoRefreshModels) return
+
+			for (const providerName of refreshableProviderNames) {
+
+				const { _enabled: enabled } = this.voidSettingsService.state.settingsOfProvider[providerName]
+				this.refreshModels(providerName, !enabled, { isPolling: true, isInternal: true })
+
+				// every time providerName.enabled changes, refresh models too, like a useEffect
+				let relevantVals = () => refreshBasedOn[providerName].map(settingName => this.voidSettingsService.state.settingsOfProvider[providerName][settingName])
+				let prevVals = relevantVals() // each iteration of a for loop has its own context and vars, so this is ok
+				disposables.add(
+					this.voidSettingsService.onDidChangeState(() => { // we might want to debounce this
+						const newVals = relevantVals()
+						if (!eq(prevVals, newVals)) {
+
+							const prevEnabled = prevVals[0] as boolean
+							const enabled = newVals[0] as boolean
+
+							// if it was just enabled, or there was a change and it wasn't to the enabled state, refresh
+							if ((enabled && !prevEnabled) || (!enabled && !prevEnabled)) {
+								// if user just clicked enable, refresh
+								this.refreshModels(providerName, !enabled, { isPolling: false, isInternal: true })
+							}
+							else {
+								// else if user just clicked disable, don't refresh
+
+								// //give cooldown before re-enabling (or at least re-fetching)
+								// const timeoutId = setTimeout(() => this.refreshModels(providerName, !enabled), COOLDOWN_TIMEOUT)
+								// this._setTimeoutId(providerName, timeoutId)
+							}
+							prevVals = newVals
+						}
+					})
+				)
+			}
+		}
+
+		// on mount (when get init settings state), and if a relevant feature flag changes (detected natively right now by refreshing if any flag changes), start refreshing models
+		voidSettingsService.waitForInitState.then(() => {
+			initializePollingAndOnChange()
+			this._register(
+				voidSettingsService.onDidChangeState((type) => { if (type === 'featureFlagSettings') initializePollingAndOnChange() })
+			)
+		})
+
+	}
+
+	state: RefreshModelStateOfProvider = {
+		ollama: { state: 'init', timeoutId: null },
+		openAICompatible: { state: 'init', timeoutId: null },
+	}
+
+
+	// start listening for models (and don't stop until success)
+	async refreshModels(providerName: RefreshableProviderName, enableProviderOnSuccess?: boolean, options?: { isPolling?: boolean, isInternal?: boolean }) {
+
+		const { isPolling, isInternal } = options ?? {}
+
+		console.log(`refreshModels, isInternal ${isInternal} isPolling ${isPolling}`)
+
+		this._clearProviderTimeout(providerName)
+
+		// start loading models
+		if (!isInternal) this._setRefreshState(providerName, 'refreshing')
+
+		const fn = providerName === 'ollama' ? this.llmMessageService.ollamaList
+			: providerName === 'openAICompatible' ? this.llmMessageService.openAICompatibleList
+				: () => { }
+
+		fn({
+			onSuccess: ({ models }) => {
+				this.voidSettingsService.setDefaultModels(providerName, models.map(model => {
+					if (providerName === 'ollama') return (model as OllamaModelResponse).name
+					else if (providerName === 'openAICompatible') return (model as OpenaiCompatibleModelResponse).id
+					else throw new Error('refreshMode fn: unknown provider', providerName)
+				}))
+
+				if (enableProviderOnSuccess) {
+					this.voidSettingsService.setSettingOfProvider(providerName, '_enabled', true)
+				}
+
+				if (!isInternal) this._setRefreshState(providerName, 'finished')
+
+			},
+			onError: ({ error }) => {
+				console.log('retrying list models:', providerName, error)
+			}
+		})
+
+		if (isInternal) this._setRefreshState(providerName, 'finished_invisible')
+
+		// check if we should poll
+		// if it was originally called as `isPolling` and if the `autoRefreshModels` flag is enabled
+		if (isPolling && this.voidSettingsService.state.featureFlagSettings.autoRefreshModels) {
+			const timeoutId = setTimeout(() => this.refreshModels(providerName, enableProviderOnSuccess, options), REFRESH_INTERVAL)
+			this._setTimeoutId(providerName, timeoutId)
+		}
+	}
+
+	_clearAllTimeouts() {
+		for (const providerName of refreshableProviderNames) {
+			this._clearProviderTimeout(providerName)
+		}
+	}
+
+	_clearProviderTimeout(providerName: RefreshableProviderName) {
+		// cancel any existing poll
+		if (this.state[providerName].timeoutId) {
+			clearTimeout(this.state[providerName].timeoutId)
+			this._setTimeoutId(providerName, null)
+		}
+	}
+
+	private _setTimeoutId(providerName: RefreshableProviderName, timeoutId: NodeJS.Timeout | null) {
+		this.state[providerName].timeoutId = timeoutId
+	}
+
+	private _setRefreshState(providerName: RefreshableProviderName, state: RefreshableState['state']) {
+		this.state[providerName].state = state
+		this._onDidChangeState.fire(providerName)
+	}
+}
+
+registerSingleton(IRefreshModelService, RefreshModelService, InstantiationType.Eager);
+

src/vs/platform/void/common/voidSettingsService.ts

@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { deepClone } from '../../../base/common/objects.js';
+import { IEncryptionService } from '../../encryption/common/encryptionService.js';
+import { registerSingleton, InstantiationType } from '../../instantiation/common/extensions.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { IStorageService, StorageScope, StorageTarget } from '../../storage/common/storage.js';
+import { defaultSettingsOfProvider, FeatureName, ProviderName, ModelSelectionOfFeature, SettingsOfProvider, SettingName, providerNames, ModelSelection, modelSelectionsEqual, featureNames, modelInfoOfDefaultNames, VoidModelInfo, FeatureFlagSettings, FeatureFlagName, defaultFeatureFlagSettings } from './voidSettingsTypes.js';
+
+
+const STORAGE_KEY = 'void.voidSettingsStorage'
+
+type SetSettingOfProviderFn = <S extends SettingName>(
+	providerName: ProviderName,
+	settingName: S,
+	newVal: SettingsOfProvider[ProviderName][S extends keyof SettingsOfProvider[ProviderName] ? S : never],
+) => Promise<void>;
+
+type SetModelSelectionOfFeatureFn = <K extends FeatureName>(
+	featureName: K,
+	newVal: ModelSelectionOfFeature[K],
+	options?: { doNotApplyEffects?: true }
+) => Promise<void>;
+
+type SetFeatureFlagFn = (flagName: FeatureFlagName, newVal: boolean) => void;
+
+export type ModelOption = { text: string, value: ModelSelection }
+
+
+
+export type VoidSettingsState = {
+	readonly settingsOfProvider: SettingsOfProvider; // optionsOfProvider
+	readonly modelSelectionOfFeature: ModelSelectionOfFeature; // stateOfFeature
+	readonly featureFlagSettings: FeatureFlagSettings;
+
+	readonly _modelOptions: ModelOption[] // computed based on the two above items
+}
+
+type EventProp = Exclude<keyof VoidSettingsState, '_modelOptions'> | 'all'
+
+
+export interface IVoidSettingsService {
+	readonly _serviceBrand: undefined;
+	readonly state: VoidSettingsState; // in order to play nicely with react, you should immutably change state
+	readonly waitForInitState: Promise<void>;
+
+	onDidChangeState: Event<EventProp>;
+
+	setSettingOfProvider: SetSettingOfProviderFn;
+	setModelSelectionOfFeature: SetModelSelectionOfFeatureFn;
+	setFeatureFlag: SetFeatureFlagFn;
+
+	setDefaultModels(providerName: ProviderName, modelNames: string[]): void;
+	toggleModelHidden(providerName: ProviderName, modelName: string): void;
+	addModel(providerName: ProviderName, modelName: string): void;
+	deleteModel(providerName: ProviderName, modelName: string): boolean;
+}
+
+
+let _computeModelOptions = (settingsOfProvider: SettingsOfProvider) => {
+	let modelOptions: ModelOption[] = []
+	for (const providerName of providerNames) {
+		const providerConfig = settingsOfProvider[providerName]
+		if (!providerConfig._enabled) continue // if disabled, don't display model options
+		for (const { modelName, isHidden } of providerConfig.models) {
+			if (isHidden) continue
+			modelOptions.push({ text: `${modelName} (${providerName})`, value: { providerName, modelName } })
+		}
+	}
+	return modelOptions
+}
+
+
+const defaultState = () => {
+	const d: VoidSettingsState = {
+		settingsOfProvider: deepClone(defaultSettingsOfProvider),
+		modelSelectionOfFeature: { 'Ctrl+L': null, 'Ctrl+K': null, 'Autocomplete': null },
+		featureFlagSettings: deepClone(defaultFeatureFlagSettings),
+		_modelOptions: _computeModelOptions(defaultSettingsOfProvider), // computed
+	}
+	return d
+}
+
+
+export const IVoidSettingsService = createDecorator<IVoidSettingsService>('VoidSettingsService');
+class VoidSettingsService extends Disposable implements IVoidSettingsService {
+	_serviceBrand: undefined;
+
+	private readonly _onDidChangeState = new Emitter<EventProp>();
+	readonly onDidChangeState: Event<EventProp> = this._onDidChangeState.event; // this is primarily for use in react, so react can listen + update on state changes
+
+	state: VoidSettingsState;
+	waitForInitState: Promise<void> // await this if you need a valid state initially
+
+	constructor(
+		@IStorageService private readonly _storageService: IStorageService,
+		@IEncryptionService private readonly _encryptionService: IEncryptionService,
+		// could have used this, but it's clearer the way it is (+ slightly different eg StorageTarget.USER)
+		// @ISecretStorageService private readonly _secretStorageService: ISecretStorageService,
+	) {
+		super()
+
+		// at the start, we haven't read the partial config yet, but we need to set state to something
+		this.state = defaultState()
+
+		let resolver: () => void = () => { }
+		this.waitForInitState = new Promise((res, rej) => resolver = res)
+
+		// read and update the actual state immediately
+		this._readState().then(s => {
+			this.state = s
+			resolver()
+			this._onDidChangeState.fire('all')
+		})
+	}
+
+	private async _readState(): Promise<VoidSettingsState> {
+		const encryptedState = this._storageService.get(STORAGE_KEY, StorageScope.APPLICATION)
+
+		if (!encryptedState)
+			return defaultState()
+
+		const stateStr = await this._encryptionService.decrypt(encryptedState)
+		return JSON.parse(stateStr)
+	}
+
+
+	private async _storeState() {
+		const state = this.state
+		const encryptedState = await this._encryptionService.encrypt(JSON.stringify(state))
+		this._storageService.store(STORAGE_KEY, encryptedState, StorageScope.APPLICATION, StorageTarget.USER);
+	}
+
+	setSettingOfProvider: SetSettingOfProviderFn = async (providerName, settingName, newVal) => {
+
+		const newModelSelectionOfFeature = this.state.modelSelectionOfFeature
+
+		const newSettingsOfProvider = {
+			...this.state.settingsOfProvider,
+			[providerName]: {
+				...this.state.settingsOfProvider[providerName],
+				[settingName]: newVal,
+			}
+		}
+
+		const newFeatureFlags = this.state.featureFlagSettings
+
+		// if changed models or enabled a provider, recompute models list
+		const modelsListChanged = settingName === 'models' || settingName === '_enabled'
+		const newModelsList = modelsListChanged ? _computeModelOptions(newSettingsOfProvider) : this.state._modelOptions
+
+		const newState: VoidSettingsState = {
+			modelSelectionOfFeature: newModelSelectionOfFeature,
+			settingsOfProvider: newSettingsOfProvider,
+			featureFlagSettings: newFeatureFlags,
+			_modelOptions: newModelsList,
+		}
+
+		// this must go above this.setanythingelse()
+		this.state = newState
+
+		// if the user-selected model is no longer in the list, update the selection for each feature that needs it to something relevant (the 0th model available, or null)
+		if (modelsListChanged) {
+			for (const featureName of featureNames) {
+
+				const currentSelection = newModelSelectionOfFeature[featureName]
+				const selnIdx = currentSelection === null ? -1 : newModelsList.findIndex(m => modelSelectionsEqual(m.value, currentSelection))
+
+				if (selnIdx === -1) {
+					if (newModelsList.length !== 0)
+						this.setModelSelectionOfFeature(featureName, newModelsList[0].value, { doNotApplyEffects: true })
+					else
+						this.setModelSelectionOfFeature(featureName, null, { doNotApplyEffects: true })
+				}
+			}
+		}
+
+		await this._storeState()
+		this._onDidChangeState.fire('settingsOfProvider')
+	}
+
+
+	setFeatureFlag: SetFeatureFlagFn = async (flagName, newVal) => {
+		const newState = {
+			...this.state,
+			featureFlagSettings: {
+				...this.state.featureFlagSettings,
+				[flagName]: newVal
+			}
+		}
+		this.state = newState
+		await this._storeState()
+		this._onDidChangeState.fire('featureFlagSettings')
+
+	}
+
+
+	setModelSelectionOfFeature: SetModelSelectionOfFeatureFn = async (featureName, newVal, options) => {
+		const newState: VoidSettingsState = {
+			...this.state,
+			modelSelectionOfFeature: {
+				...this.state.modelSelectionOfFeature,
+				[featureName]: newVal
+			}
+		}
+
+		this.state = newState
+
+		if (options?.doNotApplyEffects)
+			return
+
+		await this._storeState()
+		this._onDidChangeState.fire('modelSelectionOfFeature')
+	}
+
+
+
+	setDefaultModels(providerName: ProviderName, newDefaultModelNames: string[]) {
+		const { models } = this.state.settingsOfProvider[providerName]
+		const newDefaultModels = modelInfoOfDefaultNames(newDefaultModelNames, { isAutodetected: true, existingModels: models })
+		const newModels = [
+			...newDefaultModels,
+			...models.filter(m => !m.isDefault), // keep any non-default models
+		]
+		this.setSettingOfProvider(providerName, 'models', newModels)
+	}
+	toggleModelHidden(providerName: ProviderName, modelName: string) {
+		const { models } = this.state.settingsOfProvider[providerName]
+		const modelIdx = models.findIndex(m => m.modelName === modelName)
+		if (modelIdx === -1) return
+		const newModels: VoidModelInfo[] = [
+			...models.slice(0, modelIdx),
+			{ ...models[modelIdx], isHidden: !models[modelIdx].isHidden },
+			...models.slice(modelIdx + 1, Infinity)
+		]
+		this.setSettingOfProvider(providerName, 'models', newModels)
+	}
+	addModel(providerName: ProviderName, modelName: string) {
+		const { models } = this.state.settingsOfProvider[providerName]
+		const existingIdx = models.findIndex(m => m.modelName === modelName)
+		if (existingIdx !== -1) return // if exists, do nothing
+		const newModels = [
+			...models,
+			{ modelName, isDefault: false, isHidden: false }
+		]
+		this.setSettingOfProvider(providerName, 'models', newModels)
+	}
+	deleteModel(providerName: ProviderName, modelName: string): boolean {
+		const { models } = this.state.settingsOfProvider[providerName]
+		const delIdx = models.findIndex(m => m.modelName === modelName)
+		if (delIdx === -1) return false
+		const newModels = [
+			...models.slice(0, delIdx), // delete the idx
+			...models.slice(delIdx + 1, Infinity)
+		]
+		this.setSettingOfProvider(providerName, 'models', newModels)
+		return true
+	}
+
+}
+
+
+registerSingleton(IVoidSettingsService, VoidSettingsService, InstantiationType.Eager);

src/vs/platform/void/common/voidSettingsTypes.ts

@@ -0,0 +1,415 @@
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+
+export type VoidModelInfo = {
+	modelName: string,
+	isDefault: boolean, // whether or not it's a default for its provider
+	isHidden: boolean, // whether or not the user is hiding it
+	isAutodetected?: boolean, // whether the model was autodetected by polling
+}
+
+type ModelInfoOfDefaultNamesOptions = { isAutodetected: true, existingModels: VoidModelInfo[] } // | { isOtherOption: true, ...otherOptions }
+export const modelInfoOfDefaultNames = (modelNames: string[], options?: ModelInfoOfDefaultNamesOptions): VoidModelInfo[] => {
+
+	const { isAutodetected, existingModels } = options ?? {}
+	const isDefault = true
+	const isHidden = modelNames.length >= 10 // hide all models if there are a ton of them, and make user enable them individually
+
+	if (!existingModels) {
+
+		return modelNames.map((modelName, i) => ({ modelName, isDefault, isAutodetected, isHidden, }))
+
+	} else {
+		// keep existing `isHidden` property
+
+		const existingModelsMap: Record<string, VoidModelInfo> = {}
+		for (const em of existingModels) {
+			existingModelsMap[em.modelName] = em
+		}
+
+		return modelNames.map((modelName, i) => ({ modelName, isDefault, isAutodetected, isHidden: !!existingModelsMap[modelName]?.isHidden, }))
+
+	}
+
+}
+
+// https://docs.anthropic.com/en/docs/about-claude/models
+export const defaultAnthropicModels = modelInfoOfDefaultNames([
+	'claude-3-5-sonnet-20241022',
+	'claude-3-5-haiku-20241022',
+	'claude-3-opus-20240229',
+	'claude-3-sonnet-20240229',
+	// 'claude-3-haiku-20240307',
+])
+
+
+// https://platform.openai.com/docs/models/gp
+export const defaultOpenAIModels = modelInfoOfDefaultNames([
+	'o1-preview',
+	'o1-mini',
+	'gpt-4o',
+	'gpt-4o-mini',
+	// 'gpt-4o-2024-05-13',
+	// 'gpt-4o-2024-08-06',
+	// 'gpt-4o-mini-2024-07-18',
+	// 'gpt-4-turbo',
+	// 'gpt-4-turbo-2024-04-09',
+	// 'gpt-4-turbo-preview',
+	// 'gpt-4-0125-preview',
+	// 'gpt-4-1106-preview',
+	// 'gpt-4',
+	// 'gpt-4-0613',
+	// 'gpt-3.5-turbo-0125',
+	// 'gpt-3.5-turbo',
+	// 'gpt-3.5-turbo-1106',
+])
+
+
+
+// https://console.groq.com/docs/models
+export const defaultGroqModels = modelInfoOfDefaultNames([
+	"mixtral-8x7b-32768",
+	"llama2-70b-4096",
+	"gemma-7b-it"
+])
+
+
+export const defaultGeminiModels = modelInfoOfDefaultNames([
+	'gemini-1.5-flash',
+	'gemini-1.5-pro',
+	'gemini-1.5-flash-8b',
+	'gemini-1.0-pro'
+])
+
+
+
+// export const parseMaxTokensStr = (maxTokensStr: string) => {
+// 	// parse the string but only if the full string is a valid number, eg parseInt('100abc') should return NaN
+// 	const int = isNaN(Number(maxTokensStr)) ? undefined : parseInt(maxTokensStr)
+// 	if (Number.isNaN(int))
+// 		return undefined
+// 	return int
+// }
+
+
+
+
+export const anthropicMaxPossibleTokens = (modelName: string) => {
+	if (modelName === 'claude-3-5-sonnet-20241022'
+		|| modelName === 'claude-3-5-haiku-20241022')
+		return 8192
+	if (modelName === 'claude-3-opus-20240229'
+		|| modelName === 'claude-3-sonnet-20240229'
+		|| modelName === 'claude-3-haiku-20240307')
+		return 4096
+	return 1024 // return a reasonably small number if they're using a different model
+}
+
+
+type UnionOfKeys<T> = T extends T ? keyof T : never;
+
+
+
+export const defaultProviderSettings = {
+	anthropic: {
+		apiKey: '',
+	},
+	openAI: {
+		apiKey: '',
+	},
+	ollama: {
+		endpoint: 'http://127.0.0.1:11434',
+	},
+	openRouter: {
+		apiKey: '',
+	},
+	openAICompatible: {
+		endpoint: '',
+		apiKey: '',
+	},
+	gemini: {
+		apiKey: '',
+	},
+	groq: {
+		apiKey: ''
+	}
+} as const
+
+export type ProviderName = keyof typeof defaultProviderSettings
+export const providerNames = Object.keys(defaultProviderSettings) as ProviderName[]
+
+export const localProviderNames = ['ollama', 'openAICompatible'] satisfies ProviderName[] // all local names
+export const nonlocalProviderNames = providerNames.filter((name) => !(localProviderNames as string[]).includes(name)) // all non-local names
+
+type CustomSettingName = UnionOfKeys<typeof defaultProviderSettings[ProviderName]>
+type CustomProviderSettings<providerName extends ProviderName> = {
+	[k in CustomSettingName]: k extends keyof typeof defaultProviderSettings[providerName] ? string : undefined
+}
+export const customSettingNamesOfProvider = (providerName: ProviderName) => {
+	return Object.keys(defaultProviderSettings[providerName]) as CustomSettingName[]
+}
+
+
+type CommonProviderSettings = {
+	_enabled: boolean | undefined, // undefined initially, computed when user types in all fields
+	models: VoidModelInfo[],
+}
+
+export type SettingsForProvider<providerName extends ProviderName> = CustomProviderSettings<providerName> & CommonProviderSettings
+
+// part of state
+export type SettingsOfProvider = {
+	[providerName in ProviderName]: SettingsForProvider<providerName>
+}
+
+
+export type SettingName = keyof SettingsForProvider<ProviderName>
+
+
+
+
+
+type DisplayInfoForProviderName = {
+	title: string,
+	desc?: string,
+}
+
+export const displayInfoOfProviderName = (providerName: ProviderName): DisplayInfoForProviderName => {
+	if (providerName === 'anthropic') {
+		return {
+			title: 'Anthropic',
+		}
+	}
+	else if (providerName === 'openAI') {
+		return {
+			title: 'OpenAI',
+		}
+	}
+	else if (providerName === 'openRouter') {
+		return {
+			title: 'OpenRouter',
+		}
+	}
+	else if (providerName === 'ollama') {
+		return {
+			title: 'Ollama',
+
+		}
+	}
+	else if (providerName === 'openAICompatible') {
+		return {
+			title: 'OpenAI-Compatible',
+		}
+	}
+	else if (providerName === 'gemini') {
+		return {
+			title: 'Gemini',
+		}
+	}
+	else if (providerName === 'groq') {
+		return {
+			title: 'Groq',
+		}
+	}
+
+	throw new Error(`descOfProviderName: Unknown provider name: "${providerName}"`)
+}
+
+type DisplayInfo = {
+	title: string,
+	placeholder: string,
+	subTextMd?: string,
+}
+export const displayInfoOfSettingName = (providerName: ProviderName, settingName: SettingName): DisplayInfo => {
+	if (settingName === 'apiKey') {
+		return {
+			title: 'API Key',
+			placeholder: providerName === 'anthropic' ? 'sk-ant-key...' : // sk-ant-api03-key
+				providerName === 'openAI' ? 'sk-proj-key...' :
+					providerName === 'openRouter' ? 'sk-or-key...' : // sk-or-v1-key
+						providerName === 'gemini' ? 'key...' :
+							providerName === 'groq' ? 'gsk_key...' :
+								providerName === 'openAICompatible' ? 'sk-key...' :
+									'(never)',
+
+			subTextMd: providerName === 'anthropic' ? 'Get your [API Key here](https://console.anthropic.com/settings/keys).' :
+				providerName === 'openAI' ? 'Get your [API Key here](https://platform.openai.com/api-keys).' :
+					providerName === 'openRouter' ? 'Get your [API Key here](https://openrouter.ai/settings/keys).' :
+						providerName === 'gemini' ? 'Get your [API Key here](https://aistudio.google.com/apikey).' :
+							providerName === 'groq' ? 'Get your [API Key here](https://console.groq.com/keys).' :
+								providerName === 'openAICompatible' ? 'Add any OpenAI-Compatible endpoint.' :
+									undefined,
+		}
+	}
+	else if (settingName === 'endpoint') {
+		return {
+			title: providerName === 'ollama' ? 'Endpoint' :
+				providerName === 'openAICompatible' ? 'baseURL' // (do not include /chat/completions)
+					: '(never)',
+
+			placeholder: providerName === 'ollama' ? defaultProviderSettings.ollama.endpoint
+				: providerName === 'openAICompatible' ? 'https://my-website.com/v1'
+					: '(never)',
+
+			subTextMd: providerName === 'ollama' ? 'If you would like to change this endpoint, please read more about [Endpoints here](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-can-i-expose-ollama-on-my-network).' :
+				undefined,
+		}
+	}
+	else if (settingName === '_enabled') {
+		return {
+			title: '(never)',
+			placeholder: '(never)',
+		}
+	}
+	else if (settingName === 'models') {
+		return {
+			title: '(never)',
+			placeholder: '(never)',
+		}
+	}
+
+	throw new Error(`displayInfo: Unknown setting name: "${settingName}"`)
+
+}
+
+
+
+
+const defaultCustomSettings: Record<CustomSettingName, undefined> = {
+	apiKey: undefined,
+	endpoint: undefined,
+}
+
+export const voidInitModelOptions = {
+	anthropic: {
+		models: defaultAnthropicModels,
+	},
+	openAI: {
+		models: defaultOpenAIModels,
+	},
+	ollama: {
+		models: [],
+	},
+	openRouter: {
+		models: [], // any string
+	},
+	openAICompatible: {
+		models: [],
+	},
+	gemini: {
+		models: defaultGeminiModels,
+	},
+	groq: {
+		models: defaultGroqModels,
+	},
+}
+
+
+// used when waiting and for a type reference
+export const defaultSettingsOfProvider: SettingsOfProvider = {
+	anthropic: {
+		_enabled: undefined,
+		...defaultCustomSettings,
+		...defaultProviderSettings.anthropic,
+		...voidInitModelOptions.anthropic,
+	},
+	openAI: {
+		_enabled: undefined,
+		...defaultCustomSettings,
+		...defaultProviderSettings.openAI,
+		...voidInitModelOptions.openAI,
+	},
+	gemini: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.gemini,
+		...voidInitModelOptions.gemini,
+		_enabled: undefined,
+	},
+	groq: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.groq,
+		...voidInitModelOptions.groq,
+		_enabled: undefined,
+	},
+	ollama: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.ollama,
+		...voidInitModelOptions.ollama,
+		_enabled: undefined,
+	},
+	openRouter: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.openRouter,
+		...voidInitModelOptions.openRouter,
+		_enabled: undefined,
+	},
+	openAICompatible: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.openAICompatible,
+		...voidInitModelOptions.openAICompatible,
+		_enabled: undefined,
+	},
+}
+
+
+export type ModelSelection = { providerName: ProviderName, modelName: string }
+
+export const modelSelectionsEqual = (m1: ModelSelection, m2: ModelSelection) => {
+	return m1.modelName === m2.modelName && m1.providerName === m2.providerName
+}
+
+// this is a state
+export type ModelSelectionOfFeature = {
+	'Ctrl+L': ModelSelection | null,
+	'Ctrl+K': ModelSelection | null,
+	'Autocomplete': ModelSelection | null,
+}
+export type FeatureName = keyof ModelSelectionOfFeature
+export const featureNames = ['Ctrl+L', 'Ctrl+K', 'Autocomplete'] as const
+
+
+
+
+
+
+
+// the models of these can be refreshed (in theory all can, but not all should)
+export const refreshableProviderNames = localProviderNames
+export type RefreshableProviderName = typeof refreshableProviderNames[number]
+
+
+
+
+
+
+
+
+export type FeatureFlagSettings = {
+	autoRefreshModels: boolean;
+}
+export const defaultFeatureFlagSettings: FeatureFlagSettings = {
+	autoRefreshModels: true,
+}
+
+export type FeatureFlagName = keyof FeatureFlagSettings
+export const featureFlagNames = Object.keys(defaultFeatureFlagSettings) as FeatureFlagName[]
+
+type FeatureFlagDisplayInfo = {
+	description: string,
+}
+export const displayInfoOfFeatureFlag = (featureFlag: FeatureFlagName): FeatureFlagDisplayInfo => {
+	if (featureFlag === 'autoRefreshModels') {
+		return {
+			description: `Automatically detect local providers and models (${refreshableProviderNames.map(providerName => displayInfoOfProviderName(providerName).title).join(', ')}).`,
+		}
+	}
+	throw new Error(`featureFlagInfo: Unknown feature flag: "${featureFlag}"`)
+}
+
+

src/vs/platform/void/electron-main/llmMessage/anthropic.ts

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import Anthropic from '@anthropic-ai/sdk';
+import { _InternalSendLLMMessageFnType } from '../../common/llmMessageTypes.js';
+import { anthropicMaxPossibleTokens } from '../../common/voidSettingsTypes.js';
+
+// Anthropic
+type LLMMessageAnthropic = {
+	role: 'user' | 'assistant';
+	content: string;
+}
+export const sendAnthropicMsg: _InternalSendLLMMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+
+	const thisConfig = settingsOfProvider.anthropic
+
+	const maxTokens = anthropicMaxPossibleTokens(modelName)
+	if (maxTokens === undefined) {
+		onError({ message: `Please set a value for Max Tokens.`, fullError: null })
+		return
+	}
+
+	const anthropic = new Anthropic({ apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true });
+
+	// find system messages and concatenate them
+	const systemMessage = messages
+		.filter(msg => msg.role === 'system')
+		.map(msg => msg.content)
+		.join('\n');
+
+	// remove system messages for Anthropic
+	const anthropicMessages = messages.filter(msg => msg.role !== 'system') as LLMMessageAnthropic[]
+
+
+
+	const stream = anthropic.messages.stream({
+		system: systemMessage,
+		messages: anthropicMessages,
+		model: modelName,
+		max_tokens: maxTokens,
+	});
+
+
+	// when receive text
+	stream.on('text', (newText, fullText) => {
+		onText({ newText, fullText })
+	})
+
+	// when we get the final message on this stream (or when error/fail)
+	stream.on('finalMessage', (claude_response) => {
+		// stringify the response's content
+		const content = claude_response.content.map(c => c.type === 'text' ? c.text : c.type).join('\n');
+		onFinalMessage({ fullText: content })
+	})
+
+	stream.on('error', (error) => {
+		// the most common error will be invalid API key (401), so we handle this with a nice message
+		if (error instanceof Anthropic.APIError && error.status === 401) {
+			onError({ message: 'Invalid API key.', fullError: error })
+		}
+		else {
+			onError({ message: error + '', fullError: error }) // anthropic errors can be stringified nicely like this
+		}
+	})
+
+	// TODO need to test this to make sure it works, it might throw an error
+	_setAborter(() => stream.controller.abort())
+
+};

src/vs/platform/void/electron-main/llmMessage/gemini.ts

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Content, GoogleGenerativeAI, GoogleGenerativeAIFetchError } from '@google/generative-ai';
+import { _InternalSendLLMMessageFnType } from '../../common/llmMessageTypes.js';
+
+// Gemini
+export const sendGeminiMsg: _InternalSendLLMMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+
+	let fullText = ''
+
+	const thisConfig = settingsOfProvider.gemini
+
+	const genAI = new GoogleGenerativeAI(thisConfig.apiKey);
+	const model = genAI.getGenerativeModel({ model: modelName });
+
+	// remove system messages that get sent to Gemini
+	// str of all system messages
+	const systemMessage = messages
+		.filter(msg => msg.role === 'system')
+		.map(msg => msg.content)
+		.join('\n');
+
+	// Convert messages to Gemini format
+	const geminiMessages: Content[] = messages
+		.filter(msg => msg.role !== 'system')
+		.map((msg, i) => ({
+			parts: [{ text: msg.content }],
+			role: msg.role === 'assistant' ? 'model' : 'user'
+		}))
+
+	model.generateContentStream({ contents: geminiMessages, systemInstruction: systemMessage, })
+		.then(async response => {
+			_setAborter(() => response.stream.return(fullText))
+
+			for await (const chunk of response.stream) {
+				const newText = chunk.text();
+				fullText += newText;
+				onText({ newText, fullText });
+			}
+			onFinalMessage({ fullText });
+		})
+		.catch((error) => {
+			if (error instanceof GoogleGenerativeAIFetchError && error.status === 400) {
+				onError({ message: 'Invalid API key.', fullError: null });
+			}
+			else {
+				onError({ message: error + '', fullError: error });
+			}
+		})
+}

src/vs/platform/void/electron-main/llmMessage/greptile.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+// // Greptile
+// // https://docs.greptile.com/api-reference/query
+// // https://docs.greptile.com/quickstart#sample-response-streamed
+
+// import { SendLLMMessageFnTypeInternal } from '../../common/llmMessageTypes.js';
+
+// export const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, _setAborter }) => {
+
+// 	let fullText = ''
+
+// 	const thisConfig = settingsOfProvider.greptile
+
+// 	fetch('https://api.greptile.com/v2/query', {
+// 		method: 'POST',
+// 		headers: {
+// 			'Authorization': `Bearer ${thisConfig.apikey}`,
+// 			'X-Github-Token': `${thisConfig.githubPAT}`,
+// 			'Content-Type': `application/json`,
+// 		},
+// 		body: JSON.stringify({
+// 			messages,
+// 			stream: true,
+// 			repositories: [thisConfig.repoinfo],
+// 		}),
+// 	})
+// 		// this is {message}\n{message}\n{message}...\n
+// 		.then(async response => {
+// 			const text = await response.text()
+// 			console.log('got greptile', text)
+// 			return JSON.parse(`[${text.trim().split('\n').join(',')}]`)
+// 		})
+// 		// TODO make this actually stream, right now it just sends one message at the end
+// 		// TODO add _setAborter() when add streaming
+// 		.then(async responseArr => {
+
+// 			for (const response of responseArr) {
+// 				const type: string = response['type']
+// 				const message = response['message']
+
+// 				// when receive text
+// 				if (type === 'message') {
+// 					fullText += message
+// 					onText({ newText: message, fullText })
+// 				}
+// 				else if (type === 'sources') {
+// 					const { filepath, linestart: _, lineend: _2 } = message as { filepath: string; linestart: number | null; lineend: number | null }
+// 					fullText += filepath
+// 					onText({ newText: filepath, fullText })
+// 				}
+// 				// type: 'status' with an empty 'message' means last message
+// 				else if (type === 'status') {
+// 					if (!message) {
+// 						onFinalMessage({ fullText })
+// 					}
+// 				}
+// 			}
+
+// 		})
+// 		.catch(error => {
+// 			onError({ error })
+// 		});
+
+// }

src/vs/platform/void/electron-main/llmMessage/groq.ts

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import Groq from 'groq-sdk';
+import { _InternalSendLLMMessageFnType } from '../../common/llmMessageTypes.js';
+
+// Groq
+export const sendGroqMsg: _InternalSendLLMMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+	let fullText = '';
+
+	const thisConfig = settingsOfProvider.groq
+
+	const groq = new Groq({
+		apiKey: thisConfig.apiKey,
+		dangerouslyAllowBrowser: true
+	});
+
+	await groq.chat.completions
+		.create({
+			messages: messages,
+			model: modelName,
+			stream: true,
+			temperature: 0.7,
+			// max_tokens: parseMaxTokensStr(thisConfig.maxTokens),
+		})
+		.then(async response => {
+			_setAborter(() => response.controller.abort())
+			// when receive text
+			for await (const chunk of response) {
+				const newText = chunk.choices[0]?.delta?.content || '';
+				if (newText) {
+					fullText += newText;
+					onText({ newText, fullText });
+				}
+			}
+
+			onFinalMessage({ fullText });
+		})
+		.catch(error => {
+			onError({ message: error + '', fullError: error });
+		})
+
+
+};

src/vs/platform/void/electron-main/llmMessage/ollama.ts

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Ollama } from 'ollama';
+import { _InternalModelListFnType, _InternalSendLLMMessageFnType, OllamaModelResponse } from '../../common/llmMessageTypes.js';
+import { defaultProviderSettings } from '../../common/voidSettingsTypes.js';
+
+export const ollamaList: _InternalModelListFnType<OllamaModelResponse> = async ({ onSuccess: onSuccess_, onError: onError_, settingsOfProvider }) => {
+
+	const onSuccess = ({ models }: { models: OllamaModelResponse[] }) => {
+		onSuccess_({ models })
+	}
+
+	const onError = ({ error }: { error: string }) => {
+		onError_({ error })
+	}
+
+	try {
+		const thisConfig = settingsOfProvider.ollama
+		// if endpoint is empty, normally ollama will send to 11434, but we want it to fail - the user should type it in
+		if (!thisConfig.endpoint) throw new Error(`Ollama Endpoint was empty (please enter ${defaultProviderSettings.ollama.endpoint} in Void if you want the default url).`)
+
+		const ollama = new Ollama({ host: thisConfig.endpoint })
+		ollama.list()
+			.then((response) => {
+				const { models } = response
+				onSuccess({ models })
+			})
+			.catch((error) => {
+				onError({ error: error + '' })
+			})
+	}
+	catch (error) {
+		onError({ error: error + '' })
+	}
+}
+
+
+// Ollama
+export const sendOllamaMsg: _InternalSendLLMMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+
+	const thisConfig = settingsOfProvider.ollama
+	// if endpoint is empty, normally ollama will send to 11434, but we want it to fail - the user should type it in
+	if (!thisConfig.endpoint) throw new Error(`Ollama Endpoint was empty (please enter ${defaultProviderSettings.ollama.endpoint} if you want the default).`)
+
+	let fullText = ''
+
+	const ollama = new Ollama({ host: thisConfig.endpoint })
+
+	ollama.chat({
+		model: modelName,
+		messages: messages,
+		stream: true,
+		// options: { num_predict: parseMaxTokensStr(thisConfig.maxTokens) } // this is max_tokens
+	})
+		.then(async stream => {
+			_setAborter(() => stream.abort())
+			// iterate through the stream
+			for await (const chunk of stream) {
+				const newText = chunk.message.content;
+				fullText += newText;
+				onText({ newText, fullText });
+			}
+			onFinalMessage({ fullText });
+
+		})
+		// when error/fail
+		.catch((error) => {
+			// if (typeof error === 'object') {
+			// 	const e = error.error as ErrorResponse['error']
+			// 	if (e) {
+			// 		const name = error.name ?? 'Error'
+			// 		onError({ error: `${name}: ${e}` })
+			// 		return;
+			// 	}
+			// }
+			onError({ message: error + '', fullError: error })
+		})
+
+};
+
+
+
+// ['codestral', 'qwen2.5-coder', 'qwen2.5-coder:0.5b', 'qwen2.5-coder:1.5b', 'qwen2.5-coder:3b', 'qwen2.5-coder:7b', 'qwen2.5-coder:14b', 'qwen2.5-coder:32b', 'codegemma', 'codegemma:2b', 'codegemma:7b', 'codellama', 'codellama:7b', 'codellama:13b', 'codellama:34b', 'codellama:70b', 'codellama:code', 'codellama:python', 'command-r', 'command-r:35b', 'command-r-plus', 'command-r-plus:104b', 'deepseek-coder-v2', 'deepseek-coder-v2:16b', 'deepseek-coder-v2:236b', 'falcon2', 'falcon2:11b', 'firefunction-v2', 'firefunction-v2:70b', 'gemma', 'gemma:2b', 'gemma:7b', 'gemma2', 'gemma2:2b', 'gemma2:9b', 'gemma2:27b', 'llama2', 'llama2:7b', 'llama2:13b', 'llama2:70b', 'llama3', 'llama3:8b', 'llama3:70b', 'llama3-chatqa', 'llama3-chatqa:8b', 'llama3-chatqa:70b', 'llama3-gradient', 'llama3-gradient:8b', 'llama3-gradient:70b', 'llama3.1', 'llama3.1:8b', 'llama3.1:70b', 'llama3.1:405b', 'llava', 'llava:7b', 'llava:13b', 'llava:34b', 'llava-llama3', 'llava-llama3:8b', 'llava-phi3', 'llava-phi3:3.8b', 'mistral', 'mistral:7b', 'mistral-large', 'mistral-large:123b', 'mistral-nemo', 'mistral-nemo:12b', 'mixtral', 'mixtral:8x7b', 'mixtral:8x22b', 'moondream', 'moondream:1.8b', 'openhermes', 'openhermes:v2.5', 'phi3', 'phi3:3.8b', 'phi3:14b', 'phi3.5', 'phi3.5:3.8b', 'qwen', 'qwen:7b', 'qwen:14b', 'qwen:32b', 'qwen:72b', 'qwen:110b', 'qwen2', 'qwen2:0.5b', 'qwen2:1.5b', 'qwen2:7b', 'qwen2:72b', 'smollm', 'smollm:135m', 'smollm:360m', 'smollm:1.7b',]

src/vs/platform/void/electron-main/llmMessage/openai.ts

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import OpenAI from 'openai';
+import { _InternalModelListFnType, _InternalSendLLMMessageFnType } from '../../common/llmMessageTypes.js';
+import { Model } from 'openai/resources/models.js';
+// import { parseMaxTokensStr } from './util.js';
+
+
+
+export const openaiCompatibleList: _InternalModelListFnType<Model> = async ({ onSuccess: onSuccess_, onError: onError_, settingsOfProvider }) => {
+	const onSuccess = ({ models }: { models: Model[] }) => {
+		onSuccess_({ models })
+	}
+
+	const onError = ({ error }: { error: string }) => {
+		onError_({ error })
+	}
+
+	try {
+		const thisConfig = settingsOfProvider.openAICompatible
+		const openai = new OpenAI({ baseURL: thisConfig.endpoint, apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true })
+
+		openai.models.list()
+			.then(async (response) => {
+				const models: Model[] = []
+				models.push(...response.data)
+				while (response.hasNextPage()) {
+					models.push(...(await response.getNextPage()).data)
+				}
+				onSuccess({ models })
+			})
+			.catch((error) => {
+				onError({ error: error + '' })
+			})
+	}
+	catch (error) {
+		onError({ error: error + '' })
+	}
+}
+
+
+
+
+// OpenAI, OpenRouter, OpenAICompatible
+export const sendOpenAIMsg: _InternalSendLLMMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName }) => {
+
+	let fullText = ''
+
+	let openai: OpenAI
+	let options: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
+
+
+	if (providerName === 'openAI') {
+		const thisConfig = settingsOfProvider.openAI
+		openai = new OpenAI({ apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true });
+		options = { model: modelName, messages: messages, stream: true, /*max_completion_tokens: parseMaxTokensStr(thisConfig.maxTokens)*/ }
+	}
+	else if (providerName === 'openRouter') {
+		const thisConfig = settingsOfProvider.openRouter
+		openai = new OpenAI({
+			baseURL: 'https://openrouter.ai/api/v1', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
+			defaultHeaders: {
+				'HTTP-Referer': 'https://voideditor.com', // Optional, for including your app on openrouter.ai rankings.
+				'X-Title': 'Void Editor', // Optional. Shows in rankings on openrouter.ai.
+			},
+		});
+		options = { model: modelName, messages: messages, stream: true, /*max_completion_tokens: parseMaxTokensStr(thisConfig.maxTokens)*/ }
+	}
+	else if (providerName === 'openAICompatible') {
+		const thisConfig = settingsOfProvider.openAICompatible
+		openai = new OpenAI({ baseURL: thisConfig.endpoint, apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true })
+		options = { model: modelName, messages: messages, stream: true, /*max_completion_tokens: parseMaxTokensStr(thisConfig.maxTokens)*/ }
+	}
+	else {
+		console.error(`sendOpenAIMsg: invalid providerName: ${providerName}`)
+		throw new Error(`providerName was invalid: ${providerName}`)
+	}
+
+	openai.models.list()
+	openai.chat.completions
+		.create(options)
+		.then(async response => {
+			_setAborter(() => response.controller.abort())
+			// when receive text
+			for await (const chunk of response) {
+				const newText = chunk.choices[0]?.delta?.content || '';
+				fullText += newText;
+				onText({ newText, fullText });
+			}
+			onFinalMessage({ fullText });
+		})
+		// when error/fail - this catches errors of both .create() and .then(for await)
+		.catch(error => {
+			if (error instanceof OpenAI.APIError && error.status === 401) {
+				onError({ message: 'Invalid API key.', fullError: error });
+			}
+			else {
+				onError({ message: error, fullError: error });
+			}
+		})
+
+};

src/vs/platform/void/electron-main/llmMessage/sendLLMMessage.ts

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { LLMMMessageParams, OnText, OnFinalMessage, OnError } from '../../common/llmMessageTypes.js';
+import { IMetricsService } from '../../common/metricsService.js';
+
+import { sendAnthropicMsg } from './anthropic.js';
+import { sendOllamaMsg } from './ollama.js';
+import { sendOpenAIMsg } from './openai.js';
+import { sendGeminiMsg } from './gemini.js';
+import { sendGroqMsg } from './groq.js';
+
+export const sendLLMMessage = ({
+	messages,
+	onText: onText_,
+	onFinalMessage: onFinalMessage_,
+	onError: onError_,
+	abortRef: abortRef_,
+	logging: { loggingName },
+	settingsOfProvider,
+	providerName,
+	modelName,
+}: LLMMMessageParams,
+
+	metricsService: IMetricsService
+) => {
+
+	// trim message content (Anthropic and other providers give an error if there is trailing whitespace)
+	messages = messages.map(m => ({ ...m, content: m.content.trim() }))
+
+	// only captures number of messages and message "shape", no actual code, instructions, prompts, etc
+	const captureChatEvent = (eventId: string, extras?: object) => {
+		metricsService.capture(eventId, {
+			providerName,
+			numMessages: messages?.length,
+			messagesShape: messages?.map(msg => ({ role: msg.role, length: msg.content.length })),
+			version: '2024-11-14',
+			...extras,
+		})
+	}
+	const submit_time = new Date()
+
+	let _fullTextSoFar = ''
+	let _aborter: (() => void) | null = null
+	let _setAborter = (fn: () => void) => { _aborter = fn }
+	let _didAbort = false
+
+	const onText: OnText = ({ newText, fullText }) => {
+		if (_didAbort) return
+		onText_({ newText, fullText })
+		_fullTextSoFar = fullText
+	}
+
+	const onFinalMessage: OnFinalMessage = ({ fullText }) => {
+		if (_didAbort) return
+		captureChatEvent(`${loggingName} - Received Full Message`, { messageLength: fullText.length, duration: new Date().getMilliseconds() - submit_time.getMilliseconds() })
+		onFinalMessage_({ fullText })
+	}
+
+	const onError: OnError = ({ message: error, fullError }) => {
+		if (_didAbort) return
+		console.log("ERROR!!!!!", error)
+		console.error('sendLLMMessage onError:', error)
+		captureChatEvent(`${loggingName} - Error`, { error })
+		onError_({ message: error, fullError })
+	}
+
+	const onAbort = () => {
+		captureChatEvent(`${loggingName} - Abort`, { messageLengthSoFar: _fullTextSoFar.length })
+		try { _aborter?.() } // aborter sometimes automatically throws an error
+		catch (e) { }
+		_didAbort = true
+	}
+	abortRef_.current = onAbort
+
+	captureChatEvent(`${loggingName} - Sending Message`, { messageLength: messages[messages.length - 1]?.content.length })
+
+	try {
+		switch (providerName) {
+			case 'anthropic':
+				sendAnthropicMsg({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
+				break;
+			case 'openAI':
+			case 'openRouter':
+			case 'openAICompatible':
+				sendOpenAIMsg({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
+				break;
+			case 'gemini':
+				sendGeminiMsg({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
+				break;
+			case 'ollama':
+				sendOllamaMsg({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
+				break;
+			case 'groq':
+				sendGroqMsg({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
+				break;
+			default:
+				onError({ message: `Error: Void provider was "${providerName}", which is not recognized.`, fullError: null })
+				break;
+		}
+	}
+
+	catch (error) {
+		if (error instanceof Error) { onError({ message: error + '', fullError: error }) }
+		else { onError({ message: `Unexpected Error in sendLLMMessage: ${error}`, fullError: error }); }
+		// ; (_aborter as any)?.()
+		// _didAbort = true
+	}
+
+
+
+}
+

src/vs/platform/void/electron-main/llmMessageChannel.ts

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+// registered in app.ts
+// code convention is to make a service responsible for this stuff, and not a channel, but having fewer files is simpler...
+
+import { IServerChannel } from '../../../base/parts/ipc/common/ipc.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { EventLLMMessageOnTextParams, EventLLMMessageOnErrorParams, EventLLMMessageOnFinalMessageParams, MainLLMMessageParams, AbortRef, LLMMMessageParams, MainLLMMessageAbortParams, MainModelListParams, ModelListParams, EventModelListOnSuccessParams, EventModelListOnErrorParams, OllamaModelResponse, OpenaiCompatibleModelResponse, } from '../common/llmMessageTypes.js';
+import { sendLLMMessage } from './llmMessage/sendLLMMessage.js'
+import { IMetricsService } from '../common/metricsService.js';
+import { ollamaList } from './llmMessage/ollama.js';
+import { openaiCompatibleList } from './llmMessage/openai.js';
+
+// NODE IMPLEMENTATION - calls actual sendLLMMessage() and returns listeners to it
+
+export class LLMMessageChannel implements IServerChannel {
+	// sendLLMMessage
+	private readonly _onText_llm = new Emitter<EventLLMMessageOnTextParams>();
+	private readonly _onFinalMessage_llm = new Emitter<EventLLMMessageOnFinalMessageParams>();
+	private readonly _onError_llm = new Emitter<EventLLMMessageOnErrorParams>();
+
+	// abort
+	private readonly _abortRefOfRequestId_llm: Record<string, AbortRef> = {}
+
+	// ollamaList
+	private readonly _onSuccess_ollama = new Emitter<EventModelListOnSuccessParams<OllamaModelResponse>>();
+	private readonly _onError_ollama = new Emitter<EventModelListOnErrorParams<OllamaModelResponse>>();
+
+	// openaiCompatibleList
+	private readonly _onSuccess_openAICompatible = new Emitter<EventModelListOnSuccessParams<OpenaiCompatibleModelResponse>>();
+	private readonly _onError_openAICompatible = new Emitter<EventModelListOnErrorParams<OpenaiCompatibleModelResponse>>();
+
+	// stupidly, channels can't take in @IService
+	constructor(
+		private readonly metricsService: IMetricsService,
+	) { }
+
+	// browser uses this to listen for changes
+	listen(_: unknown, event: string): Event<any> {
+		if (event === 'onText_llm') {
+			return this._onText_llm.event;
+		}
+		else if (event === 'onFinalMessage_llm') {
+			return this._onFinalMessage_llm.event;
+		}
+		else if (event === 'onError_llm') {
+			return this._onError_llm.event;
+		}
+		else if (event === 'onSuccess_ollama') {
+			return this._onSuccess_ollama.event;
+		}
+		else if (event === 'onError_ollama') {
+			return this._onError_ollama.event;
+		}
+		else if (event === 'onSuccess_openAICompatible') {
+			return this._onSuccess_openAICompatible.event;
+		}
+		else if (event === 'onError_openAICompatible') {
+			return this._onError_openAICompatible.event;
+		}
+		else {
+			throw new Error(`Event not found: ${event}`);
+		}
+	}
+
+	// browser uses this to call
+	async call(_: unknown, command: string, params: any): Promise<any> {
+		try {
+			if (command === 'sendLLMMessage') {
+				this._callSendLLMMessage(params)
+			}
+			else if (command === 'abort') {
+				this._callAbort(params)
+			}
+			else if (command === 'ollamaList') {
+				this._callOllamaList(params)
+			}
+			else if (command === 'openAICompatibleList') {
+				this._callOpenAICompatibleList(params)
+			}
+			else {
+				throw new Error(`Void sendLLM: command "${command}" not recognized.`)
+			}
+		}
+		catch (e) {
+			console.log('llmMessageChannel: Call Error:', e)
+		}
+	}
+
+	// the only place sendLLMMessage is actually called
+	private async _callSendLLMMessage(params: MainLLMMessageParams) {
+		const { requestId } = params;
+
+		if (!(requestId in this._abortRefOfRequestId_llm))
+			this._abortRefOfRequestId_llm[requestId] = { current: null }
+
+		const mainThreadParams: LLMMMessageParams = {
+			...params,
+			onText: ({ newText, fullText }) => { this._onText_llm.fire({ requestId, newText, fullText }); },
+			onFinalMessage: ({ fullText }) => { this._onFinalMessage_llm.fire({ requestId, fullText }); },
+			onError: ({ message: error, fullError }) => { console.log('sendLLM: firing err'); this._onError_llm.fire({ requestId, message: error, fullError }); },
+			abortRef: this._abortRefOfRequestId_llm[requestId],
+		}
+		sendLLMMessage(mainThreadParams, this.metricsService);
+	}
+
+	private _callAbort(params: MainLLMMessageAbortParams) {
+		const { requestId } = params;
+		if (!(requestId in this._abortRefOfRequestId_llm)) return
+		this._abortRefOfRequestId_llm[requestId].current?.()
+		delete this._abortRefOfRequestId_llm[requestId]
+	}
+
+	private _callOllamaList(params: MainModelListParams<OllamaModelResponse>) {
+		const { requestId } = params;
+
+		const mainThreadParams: ModelListParams<OllamaModelResponse> = {
+			...params,
+			onSuccess: ({ models }) => { this._onSuccess_ollama.fire({ requestId, models }); },
+			onError: ({ error }) => { this._onError_ollama.fire({ requestId, error }); },
+		}
+		ollamaList(mainThreadParams)
+	}
+
+	private _callOpenAICompatibleList(params: MainModelListParams<OpenaiCompatibleModelResponse>) {
+		const { requestId } = params;
+
+		const mainThreadParams: ModelListParams<OpenaiCompatibleModelResponse> = {
+			...params,
+			onSuccess: ({ models }) => { this._onSuccess_openAICompatible.fire({ requestId, models }); },
+			onError: ({ error }) => { this._onError_openAICompatible.fire({ requestId, error }); },
+		}
+		openaiCompatibleList(mainThreadParams)
+	}
+
+
+}

src/vs/platform/void/electron-main/metricsMainService.ts

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPL 3.0 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.js';
+
+import { IMetricsService } from '../common/metricsService.js';
+import { PostHog } from 'posthog-node'
+
+
+// posthog-js (old):
+// posthog.init('phc_UanIdujHiLp55BkUTjB1AuBXcasVkdqRwgnwRlWESH2', { api_host: 'https://us.i.posthog.com', })
+
+// const buildEnv = 'development';
+// const buildNumber = '1.0.0';
+// const isMac = process.platform === 'darwin';
+
+export class MetricsMainService extends Disposable implements IMetricsService {
+	_serviceBrand: undefined;
+
+	readonly _distinctId: string
+	readonly client: PostHog
+
+	constructor(
+		@ITelemetryService private readonly _telemetryService: ITelemetryService
+	) {
+		super()
+		this.client = new PostHog('phc_UanIdujHiLp55BkUTjB1AuBXcasVkdqRwgnwRlWESH2', { host: 'https://us.i.posthog.com', })
+
+		const { devDeviceId, firstSessionDate, machineId } = this._telemetryService
+		this._distinctId = devDeviceId
+		this.client.identify({ distinctId: devDeviceId, properties: { firstSessionDate, machineId } })
+
+		console.log('Void posthog metrics info:', JSON.stringify({ devDeviceId, firstSessionDate, machineId }))
+	}
+
+	capture: IMetricsService['capture'] = (event, params) => {
+		const capture = { distinctId: this._distinctId, event, properties: params } as const
+		// console.log('full capture:', capture)
+		this.client.capture(capture)
+	}
+}
+
+

src/vs/platform/windows/electron-main/windowImpl.ts

@@ -741,8 +741,12 @@ export class CodeWindow extends BaseWindow implements ICodeWindow {
 
 			cb({ cancel: false, requestHeaders: Object.assign(details.requestHeaders, headers) });
 		});
+
 	}
 
+
+
+
 	private marketplaceHeadersPromise: Promise<object> | undefined;
 	private getMarketplaceHeaders(): Promise<object> {
 		if (!this.marketplaceHeadersPromise) {

src/vs/workbench/api/browser/extensionHost.contribution.ts

@@ -90,6 +90,9 @@ import './mainThreadProfileContentHandlers.js';
 import './mainThreadAiRelatedInformation.js';
 import './mainThreadAiEmbeddingVector.js';
 
+// Void added this:
+import './mainThreadInlineDiff.js';
+
 export class ExtensionPoints implements IWorkbenchContribution {
 
 	static readonly ID = 'workbench.contrib.extensionPoints';

src/vs/workbench/api/browser/mainThreadInlineDiff.ts

@@ -0,0 +1,131 @@
+// Void created this file
+// it comes from mainThreadCodeInsets.ts
+
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { ICodeEditorService } from '../../../editor/browser/services/codeEditorService.js';
+import { MainContext, MainThreadInlineDiffShape } from '../common/extHost.protocol.js';
+import { IInlineDiffService } from '../../../editor/browser/services/inlineDiffService/inlineDiffService.js';
+import { ICodeEditor } from '../../../editor/browser/editorBrowser.js';
+import { IRange } from '../../../editor/common/core/range.js';
+import { extHostNamedCustomer, IExtHostContext } from '../../services/extensions/common/extHostCustomers.js';
+import { IUndoRedoElement, IUndoRedoService, UndoRedoElementType, UndoRedoGroup } from '../../../platform/undoRedo/common/undoRedo.js';
+import { IBulkEditService } from '../../../editor/browser/services/bulkEditService.js';
+import { WorkspaceEdit } from '../../../editor/common/languages.js';
+// import { IHistoryService } from '../../services/history/common/history.js';
+
+
+@extHostNamedCustomer(MainContext.MainThreadInlineDiff)
+export class MainThreadInlineDiff extends Disposable implements MainThreadInlineDiffShape {
+
+	// private readonly _proxy: ExtHostEditorInsetsShape;
+	// private readonly _disposables = new DisposableStore();
+
+	constructor(
+		context: IExtHostContext,
+		@IInlineDiffService private readonly _inlineDiff: IInlineDiffService,
+		@ICodeEditorService private readonly _editorService: ICodeEditorService,
+		// @IHistoryService private readonly _historyService: IHistoryService, // history service is the history of pressing alt left/right
+		@IUndoRedoService private readonly _undoRedoService: IUndoRedoService, // undoRedo service is the history of pressing ctrl+z
+		@IBulkEditService private readonly _bulkEditService: IBulkEditService,
+
+	) {
+		super();
+
+		// this._proxy = context.getProxy(ExtHostContext.ExtHostEditorInsets);
+		// this._wcHistoryService.addEntry()
+	}
+
+	_streamingState: { type: 'streaming'; editGroup: UndoRedoGroup } | { type: 'idle' } = { type: 'idle' }
+
+	startStreaming(editorId: string) {
+		const editor = this._getEditor(editorId)
+		if (!editor) return
+
+		const model = editor.getModel()
+		if (!model) return
+
+		// all changes made when streaming should be a part of the group so we can undo them all together
+		this._streamingState = {
+			type: 'streaming',
+			editGroup: new UndoRedoGroup()
+		}
+
+		// TODO probably need to convert this to a stack
+		const diffsSnapshotBefore = { placeholder: '' }
+		const diffsSnapshotAfter = { placeholder: '' }
+
+		const elt: IUndoRedoElement = {
+			type: UndoRedoElementType.Resource,
+			resource: model.uri,
+			label: 'Add Diffs',
+			code: 'undoredo.inlineDiff',
+			undo: () => {
+				// reapply diffareas and diffs here
+				console.log('reverting diffareas...', diffsSnapshotBefore.placeholder)
+			},
+			redo: () => {
+				// reapply diffareas and diffs here
+				// when done, need to record diffSnapshotAfter
+				console.log('re-applying diffareas...', diffsSnapshotAfter.placeholder)
+			}
+		}
+
+		this._undoRedoService.pushElement(elt, this._streamingState.editGroup)
+
+		// ---------- START ----------
+		editor.updateOptions({ readOnly: true })
+
+
+
+		// ---------- WHEN DONE ----------
+		editor.updateOptions({ readOnly: false })
+
+
+	}
+
+
+
+
+	streamChange(editorId: string, edit: WorkspaceEdit) {
+		const editor = this._getEditor(editorId)
+		if (!editor) return
+
+		if (this._streamingState.type !== 'streaming') {
+			console.error('Expected streamChange to be in state \'streaming\'.')
+			return
+		}
+
+		// count all changes towards the group
+		this._bulkEditService.apply(edit, { undoRedoGroupId: this._streamingState.editGroup.id, })
+
+
+	}
+
+	_getEditor = (editorId: string): ICodeEditor | undefined => {
+
+		let editor: ICodeEditor | undefined;
+		editorId = editorId.substr(0, editorId.indexOf(',')); //todo@jrieken HACK
+
+		for (const candidate of this._editorService.listCodeEditors()) {
+			if (candidate.getId() === editorId
+				// && candidate.hasModel() && isEqual(candidate.getModel().uri, URI.revive(uri))
+			) {
+				editor = candidate;
+				break;
+			}
+		}
+		return editor
+	}
+
+
+	$addDiff(editorId: string, originalText: string, range: IRange): void {
+
+		const editor = this._getEditor(editorId);
+		if (!editor) return
+
+		this._inlineDiff.addDiff(editor, originalText, range)
+	}
+
+
+
+}

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -109,6 +109,7 @@ import { ProxyIdentifier } from '../../services/extensions/common/proxyIdentifie
 import { ExcludeSettingOptions, TextSearchCompleteMessageType, TextSearchContextNew, TextSearchMatchNew } from '../../services/search/common/searchExtTypes.js';
 import type * as vscode from 'vscode';
 import { ExtHostCodeMapper } from './extHostCodeMapper.js';
+import { ExtHostInlineDiff } from './extHostInlineDiff.js';
 
 export interface IExtensionRegistries {
 	mine: ExtensionDescriptionRegistry;
@@ -221,6 +222,9 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostSpeech = rpcProtocol.set(ExtHostContext.ExtHostSpeech, new ExtHostSpeech(rpcProtocol));
 	const extHostEmbeddings = rpcProtocol.set(ExtHostContext.ExtHostEmbeddings, new ExtHostEmbeddings(rpcProtocol));
 
+	// Void added this:
+	const extHostInlineDiff = rpcProtocol.set(ExtHostContext.ExtHostInlineDiff, new ExtHostInlineDiff(rpcProtocol.getProxy(MainContext.MainThreadInlineDiff), extHostEditors));
+
 	// Check that no named customers are missing
 	const expected = Object.values<ProxyIdentifier<any>>(ExtHostContext);
 	rpcProtocol.assertRegistered(expected);
@@ -519,6 +523,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 
 		// namespace: languages
 		const languages: typeof vscode.languages = {
+
 			createDiagnosticCollection(name?: string): vscode.DiagnosticCollection {
 				return extHostDiagnostics.createDiagnosticCollection(extension.identifier, name);
 			},
@@ -553,6 +558,11 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 				return extHostLanguageFeatures.registerCodeLensProvider(extension, checkSelector(selector), provider);
 			},
 
+			// Void added addInlineDiff here:
+			addInlineDiff(editor: vscode.TextEditor, originalText: string, modifiedRange: vscode.Range): void {
+				extHostInlineDiff.addDiff(editor, originalText, modifiedRange)
+			},
+
 			// Void added this (I think will need to add this back when add ctrl+K)
 			// registerVoidCtrlKProvider(selector: vscode.DocumentSelector, provider: vscode.CodeLensProvider): vscode.Disposable {
 			// 	return extHostLanguageFeatures.registerCodeLensProvider(extension, checkSelector(selector), provider);
@@ -823,7 +833,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 				return extHostWebviewPanels.createWebviewPanel(extension, viewType, title, showOptions, options);
 			},
 			createWebviewTextEditorInset(editor: vscode.TextEditor, line: number, height: number, options?: vscode.WebviewOptions): vscode.WebviewEditorInset {
-				checkProposedApiEnabled(extension, 'editorInsets');
+				// checkProposedApiEnabled(extension, 'editorInsets'); // Void commented this out
 				return extHostEditorInsets.createWebviewEditorInset(editor, line, height, options, extension);
 			},
 			createTerminal(nameOrOptions?: vscode.TerminalOptions | vscode.ExtensionTerminalOptions | string, shellPath?: string, shellArgs?: readonly string[] | string): vscode.Terminal {

src/vs/workbench/api/common/extHost.protocol.ts

@@ -2984,7 +2984,10 @@ export const MainContext = {
 	MainThreadTesting: createProxyIdentifier<MainThreadTestingShape>('MainThreadTesting'),
 	MainThreadLocalization: createProxyIdentifier<MainThreadLocalizationShape>('MainThreadLocalizationShape'),
 	MainThreadAiRelatedInformation: createProxyIdentifier<MainThreadAiRelatedInformationShape>('MainThreadAiRelatedInformation'),
-	MainThreadAiEmbeddingVector: createProxyIdentifier<MainThreadAiEmbeddingVectorShape>('MainThreadAiEmbeddingVector')
+	MainThreadAiEmbeddingVector: createProxyIdentifier<MainThreadAiEmbeddingVectorShape>('MainThreadAiEmbeddingVector'),
+
+	// Void added this:
+	MainThreadInlineDiff: createProxyIdentifier<MainThreadInlineDiffShape>('MainThreadInlineDiff'),
 };
 
 export const ExtHostContext = {
@@ -3055,5 +3058,17 @@ export const ExtHostContext = {
 	ExtHostTimeline: createProxyIdentifier<ExtHostTimelineShape>('ExtHostTimeline'),
 	ExtHostTesting: createProxyIdentifier<ExtHostTestingShape>('ExtHostTesting'),
 	ExtHostTelemetry: createProxyIdentifier<ExtHostTelemetryShape>('ExtHostTelemetry'),
-	ExtHostLocalization: createProxyIdentifier<ExtHostLocalizationShape>('ExtHostLocalization')
+	ExtHostLocalization: createProxyIdentifier<ExtHostLocalizationShape>('ExtHostLocalization'),
+
+	// Void added this:
+	ExtHostInlineDiff: createProxyIdentifier<ExtHostInlineDiffShape>('ExtHostInlineDiff'), // Void added this
 };
+
+
+// Void added these:
+export interface ExtHostInlineDiffShape {
+	$onDidDispose(handle: number): void;
+}
+export interface MainThreadInlineDiffShape {
+	$addDiff(editorId: string, originalText: string, range: IRange): void;
+}

src/vs/workbench/api/common/extHostInlineDiff.ts

@@ -0,0 +1,63 @@
+// This file was created by Void
+// reference extHostCodeInsets.ts
+
+import { Emitter } from '../../../base/common/event.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { ExtHostInlineDiffShape, MainThreadInlineDiffShape } from './extHost.protocol.js';
+import * as vscode from 'vscode'
+import { ExtHostTextEditor } from './extHostTextEditor.js';
+import { ExtHostEditors } from './extHostTextEditors.js';
+import { Range } from '../../../workbench/api/common/extHostTypeConverters.js'
+
+export class ExtHostInlineDiff implements ExtHostInlineDiffShape {
+
+	private readonly _disposables = new DisposableStore();
+	private _insets = new Map<number, { editor: vscode.TextEditor; inset: vscode.WebviewEditorInset; onDidReceiveMessage: Emitter<any> }>();
+
+	constructor(
+		private readonly _proxy: MainThreadInlineDiffShape,
+		private readonly _editors: ExtHostEditors,
+	) { }
+
+
+	dispose(): void {
+		this._insets.forEach(value => value.inset.dispose());
+		this._disposables.dispose();
+	}
+
+
+	addDiff(editor: vscode.TextEditor, originalText: string, modifiedRange: vscode.Range) {
+
+		let apiEditor: ExtHostTextEditor | undefined;
+		for (const candidate of this._editors.getVisibleTextEditors(true)) {
+			if (candidate.value === editor) {
+				apiEditor = <ExtHostTextEditor>candidate;
+				break;
+			}
+		}
+		if (!apiEditor) {
+			throw new Error('not a visible editor');
+
+		}
+		// can't send over the editor, so just send over its id and reconstruct it. This is stupid but it's what VSCode's editorinset does - Andrew
+		const id = apiEditor.id;
+		// let uri = apiEditor.value.document.uri;
+
+		// convert to IRange
+		const range = Range.from(modifiedRange)
+
+		this._proxy.$addDiff(id, originalText, range)
+
+	}
+
+
+
+	// main thread calls this when disposes diff with this particular handle
+	$onDidDispose(handle: number): void {
+		const value = this._insets.get(handle);
+		if (value) {
+			value.inset.dispose();
+		}
+	}
+
+}

src/vs/workbench/browser/actions/layoutActions.ts

@@ -239,7 +239,7 @@ MenuRegistry.appendMenuItems([{
 		group: '3_workbench_layout_move',
 		command: {
 			id: ToggleSidebarPositionAction.ID,
-			title: localize('move second sidebar left', "Move Secondary Side Bar Left")
+			title: localize('move second sidebar left', "Move Void Side Bar Left")
 		},
 		when: ContextKeyExpr.and(ContextKeyExpr.notEquals('config.workbench.sideBar.location', 'right'), ContextKeyExpr.equals('viewLocation', ViewContainerLocationToString(ViewContainerLocation.AuxiliaryBar))),
 		order: 1
@@ -250,7 +250,7 @@ MenuRegistry.appendMenuItems([{
 		group: '3_workbench_layout_move',
 		command: {
 			id: ToggleSidebarPositionAction.ID,
-			title: localize('move second sidebar right', "Move Secondary Side Bar Right")
+			title: localize('move second sidebar right', "Move Void Side Bar Right")
 		},
 		when: ContextKeyExpr.and(ContextKeyExpr.equals('config.workbench.sideBar.location', 'right'), ContextKeyExpr.equals('viewLocation', ViewContainerLocationToString(ViewContainerLocation.AuxiliaryBar))),
 		order: 1
@@ -949,7 +949,7 @@ registerAction2(class extends Action2 {
 					if (!hasAddedView) {
 						results.push({
 							type: 'separator',
-							label: localize('secondarySideBarContainer', "Secondary Side Bar / {0}", containerModel.title)
+							label: localize('secondarySideBarContainer', "Void Side Bar / {0}", containerModel.title)
 						});
 						hasAddedView = true;
 					}
@@ -1056,7 +1056,7 @@ class MoveFocusedViewAction extends Action2 {
 		if (!(isViewSolo && currentLocation === ViewContainerLocation.AuxiliaryBar)) {
 			items.push({
 				id: '_.auxiliarybar.newcontainer',
-				label: localize('moveFocusedView.newContainerInSidePanel', "New Secondary Side Bar Entry")
+				label: localize('moveFocusedView.newContainerInSidePanel', "New Void Side Bar Entry")
 			});
 		}
 
@@ -1104,7 +1104,7 @@ class MoveFocusedViewAction extends Action2 {
 
 		items.push({
 			type: 'separator',
-			label: localize('secondarySideBar', "Secondary Side Bar")
+			label: localize('secondarySideBar', "Void Side Bar")
 		});
 
 		const pinnedAuxPanels = paneCompositePartService.getPinnedPaneCompositeIds(ViewContainerLocation.AuxiliaryBar);
@@ -1386,7 +1386,7 @@ if (!isMacintosh || !isNative) {
 ToggleVisibilityActions.push(...[
 	CreateToggleLayoutItem(ToggleActivityBarVisibilityActionId, ContextKeyExpr.notEquals('config.workbench.activityBar.location', 'hidden'), localize('activityBar', "Activity Bar"), { whenA: ContextKeyExpr.equals('config.workbench.sideBar.location', 'left'), iconA: activityBarLeftIcon, iconB: activityBarRightIcon }),
 	CreateToggleLayoutItem(ToggleSidebarVisibilityAction.ID, SideBarVisibleContext, localize('sideBar', "Primary Side Bar"), { whenA: ContextKeyExpr.equals('config.workbench.sideBar.location', 'left'), iconA: panelLeftIcon, iconB: panelRightIcon }),
-	CreateToggleLayoutItem(ToggleAuxiliaryBarAction.ID, AuxiliaryBarVisibleContext, localize('secondarySideBar', "Secondary Side Bar"), { whenA: ContextKeyExpr.equals('config.workbench.sideBar.location', 'left'), iconA: panelRightIcon, iconB: panelLeftIcon }),
+	CreateToggleLayoutItem(ToggleAuxiliaryBarAction.ID, AuxiliaryBarVisibleContext, localize('secondarySideBar', "Void Side Bar"), { whenA: ContextKeyExpr.equals('config.workbench.sideBar.location', 'left'), iconA: panelRightIcon, iconB: panelLeftIcon }),
 	CreateToggleLayoutItem(TogglePanelAction.ID, PanelVisibleContext, localize('panel', "Panel"), panelIcon),
 	CreateToggleLayoutItem(ToggleStatusbarVisibilityAction.ID, ContextKeyExpr.equals('config.workbench.statusBar.visible', true), localize('statusBar', "Status Bar"), statusBarIcon),
 ]);

src/vs/workbench/browser/layout.ts

@@ -2434,7 +2434,7 @@ export abstract class Layout extends Disposable implements IWorkbenchLayoutServi
 			comment: 'Information about the layout of the workbench during statup';
 			activityBarVisible: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or the not the activity bar is visible' };
 			sideBarVisible: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or the not the primary side bar is visible' };
-			auxiliaryBarVisible: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or the not the secondary side bar is visible' };
+			auxiliaryBarVisible: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or the not the Void side bar is visible' };
 			panelVisible: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or the not the panel is visible' };
 			statusbarVisible: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or the not the status bar is visible' };
 			sideBarPosition: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether the primary side bar is on the left or right' };

src/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarActions.ts

@@ -26,7 +26,7 @@ const auxiliaryBarLeftOffIcon = registerIcon('auxiliarybar-left-off-layout-icon'
 export class ToggleAuxiliaryBarAction extends Action2 {
 
 	static readonly ID = 'workbench.action.toggleAuxiliaryBar';
-	static readonly LABEL = localize2('toggleAuxiliaryBar', "Toggle Secondary Side Bar Visibility");
+	static readonly LABEL = localize2('toggleAuxiliaryBar', "Toggle Void Side Bar Visibility");
 
 	constructor() {
 		super({
@@ -34,7 +34,7 @@ export class ToggleAuxiliaryBarAction extends Action2 {
 			title: ToggleAuxiliaryBarAction.LABEL,
 			toggled: {
 				condition: AuxiliaryBarVisibleContext,
-				title: localize('secondary sidebar', "Secondary Side Bar"),
+				title: localize('secondary sidebar', "Void Side Bar"),
 				mnemonicTitle: localize({ key: 'secondary sidebar mnemonic', comment: ['&& denotes a mnemonic'] }, "Secondary Si&&de Bar"),
 			},
 
@@ -70,7 +70,7 @@ registerAction2(ToggleAuxiliaryBarAction);
 registerAction2(class FocusAuxiliaryBarAction extends Action2 {
 
 	static readonly ID = 'workbench.action.focusAuxiliaryBar';
-	static readonly LABEL = localize2('focusAuxiliaryBar', "Focus into Secondary Side Bar");
+	static readonly LABEL = localize2('focusAuxiliaryBar', "Focus into Void Side Bar");
 
 	constructor() {
 		super({
@@ -103,7 +103,7 @@ MenuRegistry.appendMenuItems([
 			group: '0_workbench_toggles',
 			command: {
 				id: ToggleAuxiliaryBarAction.ID,
-				title: localize('toggleSecondarySideBar', "Toggle Secondary Side Bar"),
+				title: localize('toggleSecondarySideBar', "Toggle Void Side Bar"),
 				toggled: { condition: AuxiliaryBarVisibleContext, icon: auxiliaryBarLeftIcon },
 				icon: auxiliaryBarLeftOffIcon,
 			},
@@ -116,7 +116,7 @@ MenuRegistry.appendMenuItems([
 			group: '0_workbench_toggles',
 			command: {
 				id: ToggleAuxiliaryBarAction.ID,
-				title: localize('toggleSecondarySideBar', "Toggle Secondary Side Bar"),
+				title: localize('toggleSecondarySideBar', "Toggle Void Side Bar"),
 				toggled: { condition: AuxiliaryBarVisibleContext, icon: auxiliaryBarRightIcon },
 				icon: auxiliaryBarRightOffIcon,
 			},
@@ -129,7 +129,7 @@ MenuRegistry.appendMenuItems([
 			group: '3_workbench_layout_move',
 			command: {
 				id: ToggleAuxiliaryBarAction.ID,
-				title: localize2('hideAuxiliaryBar', 'Hide Secondary Side Bar'),
+				title: localize2('hideAuxiliaryBar', 'Hide Void Side Bar'),
 			},
 			when: ContextKeyExpr.and(AuxiliaryBarVisibleContext, ContextKeyExpr.equals('viewLocation', ViewContainerLocationToString(ViewContainerLocation.AuxiliaryBar))),
 			order: 2

src/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarPart.ts

@@ -195,11 +195,13 @@ export class AuxiliaryBarPart extends AbstractPaneCompositePart {
 		const positionActions: IAction[] = [];
 		createAndFillInContextMenuActions(activityBarPositionMenu, { primary: [], secondary: positionActions });
 
+
+		// appears when right click
 		actions.push(...[
 			new Separator(),
 			new SubmenuAction('workbench.action.panel.position', localize('activity bar position', "Activity Bar Position"), positionActions),
-			toAction({ id: ToggleSidebarPositionAction.ID, label: currentPositionRight ? localize('move second side bar left', "Move Secondary Side Bar Left") : localize('move second side bar right', "Move Secondary Side Bar Right"), run: () => this.commandService.executeCommand(ToggleSidebarPositionAction.ID) }),
-			toAction({ id: ToggleAuxiliaryBarAction.ID, label: localize('hide second side bar', "Hide Secondary Side Bar"), run: () => this.commandService.executeCommand(ToggleAuxiliaryBarAction.ID) })
+			toAction({ id: ToggleSidebarPositionAction.ID, label: currentPositionRight ? localize('move second side bar left', "Move Void Side Bar Left") : localize('move second side bar right', "Move Void Side Bar Right"), run: () => this.commandService.executeCommand(ToggleSidebarPositionAction.ID) }),
+			toAction({ id: ToggleAuxiliaryBarAction.ID, label: localize('hide second side bar', "Hide Void Side Bar"), run: () => this.commandService.executeCommand(ToggleAuxiliaryBarAction.ID) })
 		]);
 	}
 

src/vs/workbench/browser/parts/editor/editorGroupWatermark.ts

@@ -4,82 +4,113 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { localize } from '../../../../nls.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { isMacintosh, isWeb, OS } from '../../../../base/common/platform.js';
+import { Disposable, DisposableStore, IDisposable } from '../../../../base/common/lifecycle.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
 import { IWorkspaceContextService, WorkbenchState } from '../../../../platform/workspace/common/workspace.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { append, clearNode, $, h } from '../../../../base/browser/dom.js';
 import { KeybindingLabel } from '../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
-import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
-import { ContextKeyExpr, ContextKeyExpression, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { defaultKeybindingLabelStyles } from '../../../../platform/theme/browser/defaultStyles.js';
 import { editorForeground, registerColor, transparent } from '../../../../platform/theme/common/colorRegistry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ColorScheme } from '../../../../platform/theme/common/theme.js';
+import { isRecentFolder, IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
+// import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { OpenFileFolderAction, OpenFolderAction } from '../../actions/workspaceActions.js';
+import { isMacintosh, isNative, OS } from '../../../../base/common/platform.js';
+import { VOID_CTRL_L_ACTION_ID } from '../../../contrib/void/browser/sidebarActions.js';
+import { VOID_CTRL_K_ACTION_ID } from '../../../contrib/void/browser/quickEditActions.js';
+import { defaultKeybindingLabelStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IWindowOpenable } from '../../../../platform/window/common/window.js';
+import { ILabelService, Verbosity } from '../../../../platform/label/common/label.js';
+import { splitRecentLabel } from '../../../../base/common/labels.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { VOID_OPEN_SETTINGS_ACTION_ID } from '../../../contrib/void/browser/voidSettingsPane.js';
+// import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 
 registerColor('editorWatermark.foreground', { dark: transparent(editorForeground, 0.6), light: transparent(editorForeground, 0.68), hcDark: editorForeground, hcLight: editorForeground }, localize('editorLineHighlight', 'Foreground color for the labels in the editor watermark.'));
 
-interface WatermarkEntry {
-	readonly text: string;
-	readonly id: string;
-	readonly mac?: boolean;
-	readonly when?: ContextKeyExpression;
-}
+// interface WatermarkEntry {
+// 	readonly text: string;
+// 	readonly id: string;
+// 	readonly mac?: boolean;
+// 	readonly when?: ContextKeyExpression;
+// }
 
-const showCommands: WatermarkEntry = { text: localize('watermark.showCommands', "Show All Commands"), id: 'workbench.action.showCommands' };
-const quickAccess: WatermarkEntry = { text: localize('watermark.quickAccess', "Go to File"), id: 'workbench.action.quickOpen' };
-const openFileNonMacOnly: WatermarkEntry = { text: localize('watermark.openFile', "Open File"), id: 'workbench.action.files.openFile', mac: false };
-const openFolderNonMacOnly: WatermarkEntry = { text: localize('watermark.openFolder', "Open Folder"), id: 'workbench.action.files.openFolder', mac: false };
-const openFileOrFolderMacOnly: WatermarkEntry = { text: localize('watermark.openFileFolder', "Open File or Folder"), id: 'workbench.action.files.openFileFolder', mac: true };
-const openRecent: WatermarkEntry = { text: localize('watermark.openRecent', "Open Recent"), id: 'workbench.action.openRecent' };
-const newUntitledFileMacOnly: WatermarkEntry = { text: localize('watermark.newUntitledFile', "New Untitled Text File"), id: 'workbench.action.files.newUntitledFile', mac: true };
-const findInFiles: WatermarkEntry = { text: localize('watermark.findInFiles', "Find in Files"), id: 'workbench.action.findInFiles' };
-const toggleTerminal: WatermarkEntry = { text: localize({ key: 'watermark.toggleTerminal', comment: ['toggle is a verb here'] }, "Toggle Terminal"), id: 'workbench.action.terminal.toggleTerminal', when: ContextKeyExpr.equals('terminalProcessSupported', true) };
-const startDebugging: WatermarkEntry = { text: localize('watermark.startDebugging', "Start Debugging"), id: 'workbench.action.debug.start', when: ContextKeyExpr.equals('terminalProcessSupported', true) };
-const toggleFullscreen: WatermarkEntry = { text: localize({ key: 'watermark.toggleFullscreen', comment: ['toggle is a verb here'] }, "Toggle Full Screen"), id: 'workbench.action.toggleFullScreen' };
-const showSettings: WatermarkEntry = { text: localize('watermark.showSettings', "Show Settings"), id: 'workbench.action.openSettings' };
+// const showCommands: WatermarkEntry = { text: localize('watermark.showCommands', "Show All Commands"), id: 'workbench.action.showCommands' };
+// const quickAccess: WatermarkEntry = { text: localize('watermark.quickAccess', "Go to File"), id: 'workbench.action.quickOpen' };
+// const openFileNonMacOnly: WatermarkEntry = { text: localize('watermark.openFile', "Open File"), id: 'workbench.action.files.openFile', mac: false };
+// const openFolderNonMacOnly: WatermarkEntry = { text: localize('watermark.openFolder', "Open Folder"), id: 'workbench.action.files.openFolder', mac: false };
+// const openFileOrFolderMacOnly: WatermarkEntry = { text: localize('watermark.openFileFolder', "Open File or Folder"), id: 'workbench.action.files.openFileFolder', mac: true };
+// const openRecent: WatermarkEntry = { text: localize('watermark.openRecent', "Open Recent"), id: 'workbench.action.openRecent' };
+// const newUntitledFileMacOnly: WatermarkEntry = { text: localize('watermark.newUntitledFile', "New Untitled Text File"), id: 'workbench.action.files.newUntitledFile', mac: true };
+// const findInFiles: WatermarkEntry = { text: localize('watermark.findInFiles', "Find in Files"), id: 'workbench.action.findInFiles' };
+// const toggleTerminal: WatermarkEntry = { text: localize({ key: 'watermark.toggleTerminal', comment: ['toggle is a verb here'] }, "Toggle Terminal"), id: 'workbench.action.terminal.toggleTerminal', when: ContextKeyExpr.equals('terminalProcessSupported', true) };
+// const startDebugging: WatermarkEntry = { text: localize('watermark.startDebugging', "Start Debugging"), id: 'workbench.action.debug.start', when: ContextKeyExpr.equals('terminalProcessSupported', true) };
+// const toggleFullscreen: WatermarkEntry = { text: localize({ key: 'watermark.toggleFullscreen', comment: ['toggle is a verb here'] }, "Toggle Full Screen"), id: 'workbench.action.toggleFullScreen' };
+// const showSettings: WatermarkEntry = { text: localize('watermark.showSettings', "Show Settings"), id: 'workbench.action.openSettings' };
 
-const noFolderEntries = [
-	showCommands,
-	openFileNonMacOnly,
-	openFolderNonMacOnly,
-	openFileOrFolderMacOnly,
-	openRecent,
-	newUntitledFileMacOnly
-];
+// // shown when Void is emtpty
+// const noFolderEntries = [
+// 	// showCommands,
+// 	openFileNonMacOnly,
+// 	openFolderNonMacOnly,
+// 	openFileOrFolderMacOnly,
+// 	openRecent,
+// 	// newUntitledFileMacOnly
+// ];
 
-const folderEntries = [
-	showCommands,
-	quickAccess,
-	findInFiles,
-	startDebugging,
-	toggleTerminal,
-	toggleFullscreen,
-	showSettings
-];
+// const folderEntries = [
+// 	showCommands,
+// 	// quickAccess,
+// 	// findInFiles,
+// 	// startDebugging,
+// 	// toggleTerminal,
+// 	// toggleFullscreen,
+// 	// showSettings
+// ];
 
 export class EditorGroupWatermark extends Disposable {
 	private readonly shortcuts: HTMLElement;
 	private readonly transientDisposables = this._register(new DisposableStore());
-	private enabled: boolean = false;
+	// private enabled: boolean = false;
 	private workbenchState: WorkbenchState;
-	private keybindingLabels = new Set<KeybindingLabel>();
+	private currentDisposables = new Set<IDisposable>();
 
 	constructor(
 		container: HTMLElement,
 		@IKeybindingService private readonly keybindingService: IKeybindingService,
 		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService,
-		@IContextKeyService private readonly contextKeyService: IContextKeyService,
-		@IConfigurationService private readonly configurationService: IConfigurationService
+		// @IContextKeyService private readonly contextKeyService: IContextKeyService,
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IThemeService private readonly themeService: IThemeService,
+		@IWorkspacesService private readonly workspacesService: IWorkspacesService,
+		@ICommandService private readonly commandService: ICommandService,
+		@IHostService private readonly hostService: IHostService,
+		@ILabelService private readonly labelService: ILabelService,
 	) {
 		super();
 
 		const elements = h('.editor-group-watermark', [
-			h('.letterpress'),
+			h('.letterpress@icon'),
 			h('.shortcuts@shortcuts'),
 		]);
 
 		append(container, elements.root);
-		this.shortcuts = elements.shortcuts;
+		this.shortcuts = elements.shortcuts; // shortcuts div is modified on render()
+
+		// void icon style
+		const updateTheme = () => {
+			const theme = this.themeService.getColorTheme().type
+			const isDark = theme === ColorScheme.DARK || theme === ColorScheme.HIGH_CONTRAST_DARK
+			elements.icon.style.maxWidth = '220px'
+			elements.icon.style.opacity = '50%'
+			elements.icon.style.filter = isDark ? '' : 'invert(1)' //brightness(.5)
+		}
+		updateTheme()
+		this._register(
+			this.themeService.onDidColorThemeChange(updateTheme)
+		)
 
 		this.registerListeners();
 
@@ -103,56 +134,182 @@ export class EditorGroupWatermark extends Disposable {
 			this.render();
 		}));
 
-		const allEntriesWhenClauses = [...noFolderEntries, ...folderEntries].filter(entry => entry.when !== undefined).map(entry => entry.when!);
-		const allKeys = new Set<string>();
-		allEntriesWhenClauses.forEach(when => when.keys().forEach(key => allKeys.add(key)));
-		this._register(this.contextKeyService.onDidChangeContext(e => {
-			if (e.affectsSome(allKeys)) {
-				this.render();
-			}
-		}));
+		// const allEntriesWhenClauses = [...noFolderEntries, ...folderEntries].filter(entry => entry.when !== undefined).map(entry => entry.when!);
+		// const allKeys = new Set<string>();
+		// allEntriesWhenClauses.forEach(when => when.keys().forEach(key => allKeys.add(key)));
+		// this._register(this.contextKeyService.onDidChangeContext(e => {
+		// 	if (e.affectsSome(allKeys)) {
+		// 		this.render();
+		// 	}
+		// }));
 	}
 
+
+
 	private render(): void {
-		const enabled = this.configurationService.getValue<boolean>('workbench.tips.enabled');
+		// const enabled = this.configurationService.getValue<boolean>('workbench.tips.enabled');
 
-		if (enabled === this.enabled) {
-			return;
-		}
+		// if (enabled === this.enabled) {
+		// 	return;
+		// }
+
+		// this.enabled = enabled;
+
+
+		// if (!enabled) {
+		// 	return;
+		// }
+
+		// const hasFolder = this.workbenchState !== WorkbenchState.EMPTY;
+		// const selected = (hasFolder ? folderEntries : noFolderEntries)
+		// 	.filter(entry => !('when' in entry) || this.contextKeyService.contextMatchesRules(entry.when))
+		// 	.filter(entry => !('mac' in entry) || entry.mac === (isMacintosh && !isWeb))
+		// 	.filter(entry => !!CommandsRegistry.getCommand(entry.id))
+		// 	.filter(entry => !!this.keybindingService.lookupKeybinding(entry.id));
 
-		this.enabled = enabled;
 		this.clear();
-
-		if (!enabled) {
-			return;
-		}
-
 		const box = append(this.shortcuts, $('.watermark-box'));
-		const folder = this.workbenchState !== WorkbenchState.EMPTY;
-		const selected = (folder ? folderEntries : noFolderEntries)
-			.filter(entry => !('when' in entry) || this.contextKeyService.contextMatchesRules(entry.when))
-			.filter(entry => !('mac' in entry) || entry.mac === (isMacintosh && !isWeb))
-			.filter(entry => !!CommandsRegistry.getCommand(entry.id))
-			.filter(entry => !!this.keybindingService.lookupKeybinding(entry.id));
+		const boxBelow = append(this.shortcuts, $(''))
+		boxBelow.style.display = 'flex'
+		boxBelow.style.flex = 'row'
+		boxBelow.style.justifyContent = 'center'
+
+
+		const update = async () => {
 
-		const update = () => {
 			clearNode(box);
-			this.keybindingLabels.forEach(label => label.dispose());
-			this.keybindingLabels.clear();
+			clearNode(boxBelow);
 
-			for (const entry of selected) {
-				const keys = this.keybindingService.lookupKeybinding(entry.id);
-				if (!keys) {
-					continue;
+			this.currentDisposables.forEach(label => label.dispose());
+			this.currentDisposables.clear();
+
+
+			// Void - if the workbench is empty, show open
+			if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
+
+				// Open a folder
+				const button = h('button')
+				button.root.classList.add('void-watermark-button')
+				button.root.style.display = 'block'
+				button.root.style.marginLeft = 'auto'
+				button.root.style.marginRight = 'auto'
+				button.root.textContent = 'Open a folder'
+				button.root.onclick = () => {
+					this.commandService.executeCommand(isMacintosh && isNative ? OpenFileFolderAction.ID : OpenFolderAction.ID)
+					// if (this.contextKeyService.contextMatchesRules(ContextKeyExpr.and(WorkbenchStateContext.isEqualTo('workspace')))) {
+					// 	this.commandService.executeCommand(OpenFolderViaWorkspaceAction.ID);
+					// } else {
+					// 	this.commandService.executeCommand(isMacintosh ? 'workbench.action.files.openFileFolder' : 'workbench.action.files.openFolder');
+					// }
 				}
+				box.appendChild(button.root);
+
+
+				// Recents
+				const recentlyOpened = await this.workspacesService.getRecentlyOpened()
+					.catch(() => ({ files: [], workspaces: [] })).then(w => w.workspaces);
+
+
+				if (recentlyOpened.length !== 0) {
+
+					const span = $('div')
+					span.textContent = 'Recent'
+					span.style.fontWeight = '500'
+					box.append(span)
+
+					box.append(
+						...recentlyOpened.map(w => {
+
+							let fullPath: string;
+							let windowOpenable: IWindowOpenable;
+							if (isRecentFolder(w)) {
+								windowOpenable = { folderUri: w.folderUri };
+								fullPath = w.label || this.labelService.getWorkspaceLabel(w.folderUri, { verbose: Verbosity.LONG });
+							}
+							else {
+								return null
+								// fullPath = w.label || this.labelService.getWorkspaceLabel(w.workspace, { verbose: Verbosity.LONG });
+								// windowOpenable = { workspaceUri: w.workspace.configPath };
+							}
+
+
+							const { name, parentPath } = splitRecentLabel(fullPath);
+
+							const li = $('li');
+							const link = $('span');
+							link.classList.add('void-link')
+
+							link.innerText = name;
+							link.title = fullPath;
+							link.setAttribute('aria-label', localize('welcomePage.openFolderWithPath', "Open folder {0} with path {1}", name, parentPath));
+							link.addEventListener('click', e => {
+								this.hostService.openWindow([windowOpenable], {
+									forceNewWindow: e.ctrlKey || e.metaKey,
+									remoteAuthority: w.remoteAuthority || null // local window if remoteAuthority is not set or can not be deducted from the openable
+								});
+								e.preventDefault();
+								e.stopPropagation();
+							});
+							li.appendChild(link);
+
+							const span = $('span');
+							span.style.paddingLeft = '4px';
+							span.classList.add('path');
+							span.classList.add('detail');
+							span.innerText = parentPath;
+							span.title = fullPath;
+							li.appendChild(span);
+
+							return li
+						}).filter(v => !!v)
+					)
+				}
+
+
+
+			}
+			else {
+
+				// show them Void keybindings
+				const keys = this.keybindingService.lookupKeybinding(VOID_CTRL_L_ACTION_ID);
 				const dl = append(box, $('dl'));
 				const dt = append(dl, $('dt'));
-				dt.textContent = entry.text;
+				dt.textContent = 'Chat'
 				const dd = append(dl, $('dd'));
 				const label = new KeybindingLabel(dd, OS, { renderUnboundKeybindings: true, ...defaultKeybindingLabelStyles });
-				label.set(keys);
-				this.keybindingLabels.add(label);
+				if (keys)
+					label.set(keys);
+				this.currentDisposables.add(label);
+
+
+				const keys2 = this.keybindingService.lookupKeybinding(VOID_CTRL_K_ACTION_ID);
+				const dl2 = append(box, $('dl'));
+				const dt2 = append(dl2, $('dt'));
+				dt2.textContent = 'Quick Edit'
+				const dd2 = append(dl2, $('dd'));
+				const label2 = new KeybindingLabel(dd2, OS, { renderUnboundKeybindings: true, ...defaultKeybindingLabelStyles });
+				if (keys2)
+					label2.set(keys2);
+				this.currentDisposables.add(label2);
+
+				const keys3 = this.keybindingService.lookupKeybinding('workbench.action.openGlobalKeybindings');
+				const button3 = append(boxBelow, $('button'));
+				button3.textContent = 'Void Settings'
+				button3.style.display = 'block'
+				button3.style.marginLeft = 'auto'
+				button3.style.marginRight = 'auto'
+				button3.classList.add('void-settings-watermark-button')
+
+				const label3 = new KeybindingLabel(button3, OS, { renderUnboundKeybindings: true, ...defaultKeybindingLabelStyles });
+				if (keys3)
+					label3.set(keys3);
+				button3.onclick = () => {
+					this.commandService.executeCommand(VOID_OPEN_SETTINGS_ACTION_ID)
+				}
+				this.currentDisposables.add(label3);
+
 			}
+
 		};
 
 		update();
@@ -167,6 +324,6 @@ export class EditorGroupWatermark extends Disposable {
 	override dispose(): void {
 		super.dispose();
 		this.clear();
-		this.keybindingLabels.forEach(label => label.dispose());
+		this.currentDisposables.forEach(label => label.dispose());
 	}
 }

src/vs/workbench/browser/parts/editor/media/editorgroupview.css

@@ -9,13 +9,15 @@
 	height: 100%;
 }
 
-.monaco-workbench .part.editor > .content .editor-group-container.empty  {
-	opacity: 0.5; /* dimmed to indicate inactive state */
+.monaco-workbench .part.editor > .content .editor-group-container.empty {
+	opacity: 0.5;
+	/* dimmed to indicate inactive state */
 }
 
 .monaco-workbench .part.editor > .content .editor-group-container.empty.active,
 .monaco-workbench .part.editor > .content .editor-group-container.empty.dragged-over {
-	opacity: 1; /* indicate active/dragged-over group through undimmed state */
+	opacity: 1;
+	/* indicate active/dragged-over group through undimmed state */
 }
 
 .monaco-workbench .part.editor > .content:not(.empty) .editor-group-container.empty.active:focus {
@@ -24,12 +26,13 @@
 }
 
 .monaco-workbench .part.editor > .content.empty .editor-group-container.empty.active:focus {
-	outline: none; /* never show outline for empty group if it is the last */
+	outline: none;
+	/* never show outline for empty group if it is the last */
 }
 
 /* Watermark & shortcuts */
 
-.monaco-workbench .part.editor > .content .editor-group-container > .editor-group-watermark  {
+.monaco-workbench .part.editor > .content .editor-group-container > .editor-group-watermark {
 	display: flex;
 	height: 100%;
 	max-width: 290px;
@@ -49,26 +52,27 @@
 	height: calc(100% - 70px);
 }
 
+/* light */
 .monaco-workbench .part.editor > .content .editor-group-container > .editor-group-watermark > .letterpress {
 	width: 100%;
 	max-height: 100%;
 	aspect-ratio: 1/1;
-	background-image: url('./letterpress-light.svg');
+	background-image: url('./void_cube_noshadow.png');
 	background-size: contain;
 	background-position-x: center;
 	background-repeat: no-repeat;
 }
 
 .monaco-workbench.vs-dark .part.editor > .content .editor-group-container .editor-group-watermark > .letterpress {
-	background-image: url('./letterpress-dark.svg');
+	background-image: url('./void_cube_noshadow.png');
 }
 
 .monaco-workbench.hc-light .part.editor > .content .editor-group-container .editor-group-watermark > .letterpress {
-	background-image: url('./letterpress-hcLight.svg');
+	background-image: url('./void_cube_noshadow.png');
 }
 
 .monaco-workbench.hc-black .part.editor > .content .editor-group-container .editor-group-watermark > .letterpress {
-	background-image: url('./letterpress-hcDark.svg');
+	background-image: url('./void_cube_noshadow.png');
 }
 
 .monaco-workbench .part.editor > .content:not(.empty) .editor-group-container > .editor-group-watermark > .shortcuts,
@@ -109,12 +113,13 @@
 
 .monaco-workbench .part.editor > .content .editor-group-container > .title {
 	position: relative;
-	box-sizing:	border-box;
+	box-sizing: border-box;
 	overflow: hidden;
 }
 
 .monaco-workbench .part.editor > .content .editor-group-container > .title:not(.tabs) {
-	display: flex; /* when tabs are not shown, use flex layout */
+	display: flex;
+	/* when tabs are not shown, use flex layout */
 	flex-wrap: nowrap;
 }
 
@@ -144,7 +149,8 @@
 .monaco-workbench .part.editor > .content .editor-group-container.empty.locked > .editor-group-container-toolbar,
 .monaco-workbench .part.editor > .content:not(.empty) .editor-group-container.empty > .editor-group-container-toolbar,
 .monaco-workbench .part.editor > .content.auxiliary .editor-group-container.empty > .editor-group-container-toolbar {
-	display: block; /* show toolbar when more than one editor group or always when auxiliary or locked */
+	display: block;
+	/* show toolbar when more than one editor group or always when auxiliary or locked */
 }
 
 .monaco-workbench .part.editor > .content .editor-group-container > .editor-group-container-toolbar .actions-container {
@@ -157,7 +163,7 @@
 
 /* Editor */
 
-.monaco-workbench .part.editor > .content .editor-group-container.empty > .editor-container  {
+.monaco-workbench .part.editor > .content .editor-group-container.empty > .editor-container {
 	display: none;
 }