fix input box

refactor: modularize LLM providers and types

.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.
 

.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,58 +1,49 @@
 # 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/4GAxHVAD))
-- Build New Features ([project](https://github.com/orgs/voideditor/projects/2/views/3))
+- Suggest New Features ([Discord](https://discord.gg/RSNjgaugJs))
+- Build New Features ([Project](https://github.com/orgs/voideditor/projects/2/views/3))
+- Submit Issues/Docs/Bugs ([Issues](https://github.com/voideditor/void/issues))
 
-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).
 
-For some useful links we've compiled see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).
+## Building the full IDE
 
-## 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.
+Please follow the steps below to build the IDE. If you have any questions, feel free to [submit an issue](https://github.com/voideditor/void/issues/new) with any build errors, or refer to VSCode's full [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page.
 
-1. Clone the repository:
+Most of Void's code lives in `src/vs/workbench/contrib/void/browser/` and `src/vs/platform/void/`.
 
-```
-git clone https://github.com/voideditor/void
-```
+### a. Build Prerequisites - Mac
 
-2. Open the folder `/extensions/void` in VS Code (open it in a new workspace, *don't* just cd into it):
+If you're using a Mac, make sure you have Python and XCode installed (you probably do by default).
 
-```
-open /extensions/void
-```
+### b. Build Prerequisites - Windows
 
-3. Install dependencies:
+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.
 
-```
-npm install
-```
+Go to the "Workloads" tab and select:
+- `Desktop development with C++`
+- `Node.js build tools`
 
-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/`.
+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`.
 
-```
-npm run build
-```
+Finally, click Install.
 
-5. Run the project by pressing <kbd>F5</kbd>.
+### c. Build Prerequisites - Linux
 
-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".
+First, make sure you've installed NodeJS and 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).
 
-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".
+### Build instructions
 
-Now that you're set up, feel free to check out our [Issues](https://github.com/voideditor/void/issues) page!
-
-## 2. Building the full IDE
-
-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`).
-
-Make sure you're on the correct NodeJS version as per `.nvmrc`.
+To build Void, first follow the prerequisite steps above for your operating system and open `void/` inside VSCode. Then:
 
 1. Install all dependencies.
 
@@ -60,104 +51,92 @@ Make sure you're on the correct NodeJS version as per `.nvmrc`.
 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.
+2. Run `cd ./src/vs/workbench/contrib/void/browser/react/` and then `node ./build.js` to build Void's external dependencies (our React components, etc).
 
-3. Run `./scripts/code.sh` in your terminal.
+3. Press <kbd>Ctrl+Shift+B</kbd>, or if you prefer using the terminal run `npm run watch`.
 
-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".
+This can take ~5 min.
 
-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 ran <kbd>Ctrl+Shift+B</kbd>, the build is done when you see two check marks.
 
-If you're on Windows, we recommend running the project inside a dev container. VSCode should prompt you to do this automatically.
+If you ran `npm run watch`, the build is done when you see something like this:
+
+```
+[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
+```
+
+<!-- 3. Press <kbd>Ctrl+Shift+B</kbd> to start the build process. -->
+
+4. In a new terminal, run `./scripts/code.sh` (Mac/Linux) or `./scripts/code.bat` (Windows). This should open up the built IDE!
+You can always press <kbd>Ctrl+Shift+P</kbd> and run "Reload Window" inside the new window to see changes without re-building.
+
+Now that you're set up, feel free to check out our [Issues](https://github.com/voideditor/void/issues) page.
+
+### Common Fixes
+
+- Make sure you have the same NodeJS version as `.nvmrc`.
+
+- If you see `[ERROR] Cannot start service: Host version "0.23.1" does not match binary version "0.23.0"`, run `npm i -D esbuild@0.23.0` or do a clean install of your npm dependencies.
+
+
+## Bundling
+
+To bundle the IDE into an executable, 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)`
 
-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.
+Please refer to our [Issues](https://github.com/voideditor/void/issues) page for the latest issues.
 
-## ⭐⭐⭐ 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.
+Examples: 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 us a message in the #general channel of the [Discord](https://discord.gg/RSNjgaugJs) for any reason. Please check in especially if you want to make a lot of changes or build a large new feature.
 
-# Submitting a Pull Request
 
-Please submit a pull request once you've made a change. Here are a few guidelines:
 
-- A PR should be about one *single* feature change. The fewer items you change, the more likely the PR is to be accepted.
+## Submitting a Pull Request
 
-- 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). 
+Please submit a pull request once you've made a change. You don't need to submit an issue.
 
-- 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.
+Please don't use AI to write your PR 🙂.
 
 # 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
 - product.json
+- package.json
 
 - 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

@@ -18,7 +18,7 @@ The Void team put together this list of links to get up and running with VSCode'
 
 ## 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/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()

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": false
-	},
-	"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 +0,0 @@
-Please see the `CONTRIBUTING.md` for information on how to contribute :)!

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,186 +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": {
-        "void.whichApi": {
-          "type": "string",
-          "default": "anthropic",
-          "description": "Choose an API provider",
-          "enum": [
-            "anthropic",
-            "openai",
-            "greptile",
-            "ollama"
-          ]
-        },
-        "void.anthropic.apiKey": {
-          "type": "string",
-          "default": "",
-          "description": "Anthropic API Key"
-        },
-        "void.anthropic.model": {
-          "type": "string",
-          "default": "claude-3-5-sonnet-20240620",
-          "description": "Anthropic Model to use.",
-          "enum": [
-            "claude-3-5-sonnet-20240620"
-          ]
-        },
-        "void.anthropic.maxTokens": {
-          "type": "string",
-          "default": "1024",
-          "description": "Anthropic max number of tokens to output.",
-          "enum":[
-            "1024",
-            "2048",
-            "4096",
-            "8192"
-          ]
-        },
-        "void.openAI.apiKey": {
-          "type": "string",
-          "default": "",
-          "description": "OpenAI API Key."
-        },
-        "void.greptile.apiKey": {
-          "type": "string",
-          "default": "",
-          "description": "Greptile API Key."
-        },
-        "void.greptile.githubPAT": {
-          "type": "string",
-          "default": "",
-          "description": "Github PAT  given to Greptile to access your repository."
-        },
-        "void.ollama.endpoint": {
-          "type": "string",
-          "default": "",
-          "description": "Ollama Endpoint. Start Ollama by running `OLLAMA_ORIGINS=\"vscode-webview://*\" ollama serve`"
-        },
-        "void.ollama.model": {
-          "type": "string",
-          "default": "",
-          "description": "Ollama model to use."
-        }
-      }
-    },
-    "commands": [
-      {
-        "command": "void.ctrl+l",
-        "title": "Show Sidebar"
-      },
-      {
-        "command": "void.ctrl+k",
-        "title": "Show Selection Lens"
-      },
-      {
-        "command": "void.approveDiff",
-        "title": "Approve Diff"
-      },
-      {
-        "command": "void.discardDiff",
-        "title": "Discard Diff"
-      },
-      {
-        "command": "void.openSettings",
-        "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.openSettings",
-          "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/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": "^6.0.0-beta",
-    "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",
-    "postcss": "^8.4.41",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-markdown": "^9.0.1",
-    "rimraf": "^6.0.1",
-    "tailwindcss": "^3.4.10",
-    "typescript": "5.5.4",
-    "typescript-eslint": "^8.3.0"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.27.1",
-    "ollama": "^0.5.9",
-    "openai": "^4.57.0"
-  }
-}

extensions/void/src/ApprovalCodeLensProvider.ts

@@ -1,186 +0,0 @@
-import * as vscode from 'vscode';
-import { SuggestedEdit } from './getDiffedLines';
-
-// each diff on the user's screen right now
-type DiffType = {
-	diffid: number,
-	lenses: vscode.CodeLens[],
-	greenRange: vscode.Range,
-	originalCode: string, // If a revert happens, we replace the greenRange with this content.
-}
-
-// 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:...
-})
-
-export class ApprovalCodeLensProvider implements vscode.CodeLensProvider {
-
-	private _diffsOfDocument: { [docUriStr: string]: DiffType[] } = {};
-	private _computedLensesOfDocument: { [docUriStr: string]: vscode.CodeLens[] } = {} // computed from diffsOfDocument[docUriStr].lenses
-	private _diffidPool = 0
-
-	private _onDidChangeCodeLenses: vscode.EventEmitter<void> = new vscode.EventEmitter<void>(); // signals a UI refresh on .fire() events
-
-	private _weAreEditing: boolean = false
-
-	// used internally by vscode
-	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._computedLensesOfDocument[docUriStr]
-	}
-
-	// declared by us, registered with vscode.languages.registerCodeLensProvider()
-	constructor() {
-		// 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()
-			this._diffsOfDocument[docUriStr].splice(0) // clear diffs
-			editor.setDecorations(greenDecoration, []) // clear decorations
-			this._computedLensesOfDocument[docUriStr] = this._diffsOfDocument[docUriStr].flatMap(diff => diff.lenses) // recompute
-			this._onDidChangeCodeLenses.fire() // refresh
-		})
-	}
-
-	// used by us only
-	private refreshLenses = (editor: vscode.TextEditor, docUriStr: string) => {
-		editor.setDecorations(greenDecoration, this._diffsOfDocument[docUriStr].map(diff => diff.greenRange)) // refresh highlighting
-		this._computedLensesOfDocument[docUriStr] = this._diffsOfDocument[docUriStr].flatMap(diff => diff.lenses) // recompute _computedLensesOfDocument (can optimize this later)
-		this._onDidChangeCodeLenses.fire() // fire event for vscode to refresh lenses
-	}
-
-	// used by us only
-	public async addNewApprovals(editor: vscode.TextEditor, suggestedEdits: SuggestedEdit[]) {
-
-		const docUri = editor.document.uri
-		const docUriStr = docUri.toString()
-
-		if (!this._diffsOfDocument[docUriStr])
-			this._diffsOfDocument[docUriStr] = []
-		if (!this._computedLensesOfDocument[docUriStr])
-			this._computedLensesOfDocument[docUriStr] = []
-
-
-		// 1. convert suggested edits (which are described using line numbers) into actual edits (described using vscode.Range, vscode.Uri)
-		// must do this before adding codelenses or highlighting so that codelens and highlights will apply to the fresh code and not the old code
-		// apply changes in reverse order so additions don't push down the line numbers of the next edit
-		let workspaceEdit = new vscode.WorkspaceEdit();
-		for (let i = suggestedEdits.length - 1; i > -1; i -= 1) {
-			let suggestedEdit = suggestedEdits[i]
-
-			let greenRange: vscode.Range
-
-			// INSERTIONS (e.g. {originalStartLine: 0, originalEndLine: -1})
-			if (suggestedEdit.originalStartLine > suggestedEdit.originalEndLine) {
-				const originalPosition = new vscode.Position(suggestedEdit.originalStartLine, 0)
-				workspaceEdit.insert(docUri, originalPosition, suggestedEdit.newContent + '\n') // add back in the line we deleted when we made the startline->endline range go negative
-				greenRange = new vscode.Range(suggestedEdit.startLine, 0, suggestedEdit.endLine + 1, 0)
-			}
-			// DELETIONS
-			else if (suggestedEdit.startLine > suggestedEdit.endLine) {
-				const deleteRange = new vscode.Range(suggestedEdit.originalStartLine, 0, suggestedEdit.originalEndLine + 1, 0)
-				workspaceEdit.delete(docUri, deleteRange)
-				greenRange = new vscode.Range(suggestedEdit.startLine, 0, suggestedEdit.startLine, 0)
-				suggestedEdit.originalContent += '\n' // add back in the line we deleted when we made the startline->endline range go negative
-			}
-			// REPLACEMENTS
-			else {
-				const originalRange = new vscode.Range(suggestedEdit.originalStartLine, 0, suggestedEdit.originalEndLine, Number.MAX_SAFE_INTEGER)
-				workspaceEdit.replace(docUri, originalRange, suggestedEdit.newContent)
-				greenRange = new vscode.Range(suggestedEdit.startLine, 0, suggestedEdit.endLine, Number.MAX_SAFE_INTEGER)
-			}
-
-			this._diffsOfDocument[docUriStr].push({
-				diffid: this._diffidPool,
-				greenRange: greenRange,
-				originalCode: suggestedEdit.originalContent,
-				lenses: [
-					new vscode.CodeLens(greenRange, { title: 'Accept', command: 'void.approveDiff', arguments: [{ diffid: this._diffidPool }] }),
-					new vscode.CodeLens(greenRange, { title: 'Reject', command: 'void.discardDiff', arguments: [{ diffid: this._diffidPool }] })
-				]
-			});
-			this._diffidPool += 1
-		}
-
-		this._weAreEditing = true
-		await vscode.workspace.applyEdit(workspaceEdit)
-		await vscode.workspace.save(docUri)
-		this._weAreEditing = false
-
-		// refresh
-		this.refreshLenses(editor, docUriStr)
-
-		console.log('diffs after added:', this._diffsOfDocument[docUriStr])
-	}
-
-	// called on void.approveDiff
-	public async approveDiff({ diffid }: { diffid: number }) {
-		const editor = vscode.window.activeTextEditor
-		if (!editor)
-			return
-
-		const docUri = editor.document.uri
-		const docUriStr = docUri.toString()
-
-		// get index of this diff in diffsOfDocument
-		const index = this._diffsOfDocument[docUriStr].findIndex(diff => diff.diffid === diffid);
-		if (index === -1) {
-			console.error('Error: DiffID could not be found: ', diffid, this._diffsOfDocument[docUriStr])
-			return
-		}
-
-		// remove this diff from the diffsOfDocument[docStr] (can change this behavior in future if add something like history)
-		this._diffsOfDocument[docUriStr].splice(index, 1)
-
-		// refresh
-		this.refreshLenses(editor, docUriStr)
-	}
-
-
-	// called on void.discardDiff
-	public async discardDiff({ diffid }: { diffid: number }) {
-		const editor = vscode.window.activeTextEditor
-		if (!editor)
-			return
-
-		const docUri = editor.document.uri
-		const docUriStr = docUri.toString()
-
-		// get index of this diff in diffsOfDocument
-		const index = this._diffsOfDocument[docUriStr].findIndex(diff => diff.diffid === diffid);
-		if (index === -1) {
-			console.error('Void error: DiffID could not be found: ', diffid, this._diffsOfDocument[docUriStr])
-			return
-		}
-
-		const { greenRange: range, lenses, originalCode } = this._diffsOfDocument[docUriStr][index] // do this before we splice and mess up index
-
-		// remove this diff from the diffsOfDocument[docStr] (can change this behavior in future if add something like history)
-		this._diffsOfDocument[docUriStr].splice(index, 1)
-
-		// clear the decoration in this diffs range
-		editor.setDecorations(greenDecoration, this._diffsOfDocument[docUriStr].map(diff => diff.greenRange))
-
-		// REVERT THE CHANGE (this is the only part that's different from approveDiff)
-		let workspaceEdit = new vscode.WorkspaceEdit();
-		workspaceEdit.replace(docUri, range, originalCode);
-		this._weAreEditing = true
-		await vscode.workspace.applyEdit(workspaceEdit)
-		await vscode.workspace.save(docUri)
-		this._weAreEditing = false
-
-		// refresh
-		this.refreshLenses(editor, docUriStr)
-	}
-}

extensions/void/src/CtrlKCodeLensProvider.ts

@@ -1,31 +0,0 @@
-import * as vscode from 'vscode';
-
-export class CtrlKCodeLensProvider implements vscode.CodeLensProvider {
-
-	private codelensesOfDocument: { [documentUri: string]: vscode.CodeLens[] } = {};
-
-	// only called by vscode's internals
-	public provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.CodeLens[]> {
-		const docUri = document.uri.toString()
-		return this.codelensesOfDocument[docUri];
-	}
-
-	// only called by us
-	public addNewCodeLens(document: vscode.TextDocument, selection: vscode.Selection) {
-
-		const docUri = document.uri.toString()
-
-		if (!this.codelensesOfDocument[docUri])
-			this.codelensesOfDocument[docUri] = []
-
-		// if any other codelens intersects with the selection, don't do it (and have the user now focus that codelens)
-		for (let lens of this.codelensesOfDocument[docUri]) {
-			if (lens.range.intersection(selection))
-				return
-		}
-
-		this.codelensesOfDocument[docUri] = [
-			...this.codelensesOfDocument[docUri],
-			new vscode.CodeLens(new vscode.Range(selection.start.line, 0, selection.end.line, Infinity), { title: '', command: '' })];
-	}
-}

extensions/void/src/SidebarWebviewProvider.ts

@@ -1,93 +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; // only used inside onDidChangeConfiguration
-
-	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("sidebar provider: resolver was undefined")
-		this._res = temp_res
-
-		vscode.workspace.onDidChangeConfiguration(event => {
-			if (event.affectsConfiguration('void.ollamaSettings.endpoint')) {
-				if (this._webviewView) {
-					this.updateWebviewHTML(this._webviewView.webview);
-				}
-			}
-		});
-	}
-
-	private updateWebviewHTML(webview: vscode.Webview) {
-		const allowed_urls = ['https://api.anthropic.com', 'https://api.openai.com', 'https://api.greptile.com'];
-		const ollamaEndpoint: string | undefined = vscode.workspace.getConfiguration('void').get('ollamaSettings.endpoint');
-		if (ollamaEndpoint)
-			allowed_urls.push(ollamaEndpoint);
-
-		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="default-src 'self'; connect-src ${allowed_urls.join(' ')}; 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,285 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import OpenAI from 'openai';
-import { Ollama } from 'ollama/browser'
-import { getVSCodeAPI } from '../sidebar/getVscodeApi';
-
-
-// always compare these against package.json to make sure every setting in this type can actually be provided by the user
-export type ApiConfig = {
-	anthropic: {
-		apikey: string,
-		model: string,
-		maxTokens: string
-	},
-	openai: {
-		apikey: string
-	},
-	greptile: {
-		apikey: string,
-		githubPAT: string,
-		repoinfo: {
-			remote: string, // e.g. 'github'
-			repository: string, // e.g. 'voideditor/void'
-			branch: string // e.g. 'main'
-		}
-	},
-	ollama: {
-		endpoint: string,
-		model: string
-	},
-	whichApi: string
-}
-
-
-
-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,
-	apiConfig: ApiConfig,
-})
-	=> {
-		abort: () => void
-	}
-
-type SendLLMMessageFnTypeExternal = (params: {
-	messages: LLMMessage[],
-	onText: OnText,
-	onFinalMessage: (input: string) => void,
-	apiConfig: ApiConfig | null,
-})
-	=> {
-		abort: () => void
-	}
-
-
-
-
-// Claude
-const sendClaudeMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, apiConfig }) => {
-
-	const anthropic = new Anthropic({ apiKey: apiConfig.anthropic.apikey, dangerouslyAllowBrowser: true }); // defaults to process.env["ANTHROPIC_API_KEY"]
-
-	const stream = anthropic.messages.stream({
-		model: apiConfig.anthropic.model,
-		max_tokens: parseInt(apiConfig.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)
-	})
-
-
-	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
-	const abort = () => {
-		// stream.abort() // this doesnt appear to do anything, but it should try to stop claude from generating anymore
-		did_abort = true
-	}
-
-	return { abort }
-
-};
-
-
-
-
-// OpenAI
-const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, apiConfig }) => {
-
-	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;
-	};
-
-	const openai = new OpenAI({ apiKey: apiConfig.openai.apikey, dangerouslyAllowBrowser: true });
-
-	openai.chat.completions.create({
-		model: 'gpt-4o-2024-08-06',
-		messages: messages,
-		stream: true,
-	})
-		.then(async response => {
-			abort = () => {
-				// response.controller.abort()
-				didAbort = true;
-			}
-			// when receive text
-			try {
-				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
-			catch (error) {
-				console.error('Error in OpenAI stream:', error);
-				onFinalMessage(fullText);
-			}
-		})
-	return { abort };
-};
-
-
-
-// Ollama
-export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, apiConfig }) => {
-
-	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: apiConfig.ollama.endpoint })
-
-	ollama.chat({
-		model: apiConfig.ollama.model,
-		messages: messages,
-		stream: true,
-	})
-		.then(async stream => {
-			abort = () => {
-				// ollama.abort()
-				didAbort = true
-			}
-			// iterate through the stream
-			try {
-				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) {
-				console.error('Error:', error);
-				onFinalMessage(fullText);
-			}
-		})
-	return { abort };
-};
-
-
-
-// Greptile
-// https://docs.greptile.com/api-reference/query
-// https://docs.greptile.com/quickstart#sample-response-streamed
-
-const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, apiConfig }) => {
-
-	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 ${apiConfig.greptile.apikey}`,
-			"X-Github-Token": `${apiConfig.greptile.githubPAT}`,
-			"Content-Type": `application/json`,
-		},
-		body: JSON.stringify({
-			messages,
-			stream: true,
-			repositories: [apiConfig.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 => {
-			console.error('Error in Greptile stream:', e);
-			onFinalMessage(fullText);
-
-		});
-
-	return { abort }
-
-}
-
-
-
-export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText, onFinalMessage, apiConfig }) => {
-	if (!apiConfig) return { abort: () => { } }
-
-	switch (apiConfig.whichApi) {
-		case 'anthropic':
-			return sendClaudeMsg({ messages, onText, onFinalMessage, apiConfig });
-		case 'openai':
-			return sendOpenAIMsg({ messages, onText, onFinalMessage, apiConfig });
-		case 'greptile':
-			return sendGreptileMsg({ messages, onText, onFinalMessage, apiConfig });
-		case 'ollama':
-			return sendOllamaMsg({ messages, onText, onFinalMessage, apiConfig });
-		default:
-			console.error(`Error: whichApi was ${apiConfig.whichApi}, which is not recognized!`);
-			return { abort: () => { } }
-		//return sendClaudeMsg({ messages, onText, onFinalMessage, apiConfig }); // TODO
-	}
-}
-

extensions/void/src/extension.ts

@@ -1,162 +0,0 @@
-import * as vscode from 'vscode';
-import { WebviewMessage } from './shared_types';
-import { CtrlKCodeLensProvider } from './CtrlKCodeLensProvider';
-import { getDiffedLines } from './getDiffedLines';
-import { ApprovalCodeLensProvider } from './ApprovalCodeLensProvider';
-import { SidebarWebviewProvider } from './SidebarWebviewProvider';
-import { ApiConfig } from './common/sendLLMMessage';
-
-const readFileContentOfUri = async (uri: vscode.Uri) => {
-	return Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf8').replace(/\r\n/g, '\n'); // must remove windows \r or every line will appear different because of it
-}
-
-
-const getApiConfig = () => {
-	const apiConfig: ApiConfig = {
-		anthropic: {
-			apikey: vscode.workspace.getConfiguration('void').get('anthropic.apiKey') ?? '',
-			model: vscode.workspace.getConfiguration('void').get('anthropic.model') ?? '',
-			maxTokens: vscode.workspace.getConfiguration('void').get('anthropic.maxTokens') ?? '',
-		},
-		openai: { apikey: vscode.workspace.getConfiguration('void').get('openAI.apiKey') ?? '' },
-		greptile: {
-			apikey: vscode.workspace.getConfiguration('void').get('greptile.apiKey') ?? '',
-			githubPAT: vscode.workspace.getConfiguration('void').get('greptile.githubPAT') ?? '',
-			repoinfo: {
-				remote: 'github',
-				repository: 'TODO',
-				branch: 'main'
-			}
-		},
-		ollama: {
-			endpoint: vscode.workspace.getConfiguration('void').get('ollama.endpoint') ?? '',
-			model: vscode.workspace.getConfiguration('void').get('ollama.model') ?? '',
-		},
-		whichApi: vscode.workspace.getConfiguration('void').get('whichApi') ?? ''
-	}
-	return apiConfig
-}
-
-
-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 WebviewMessage));
-		})
-	);
-
-	// 3. Show an approve/reject codelens above each change
-	const approvalCodeLensProvider = new ApprovalCodeLensProvider();
-	context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', approvalCodeLensProvider));
-
-	// 4. Add approve/reject commands
-	context.subscriptions.push(vscode.commands.registerCommand('void.approveDiff', async (params) => {
-		approvalCodeLensProvider.approveDiff(params)
-	}));
-	context.subscriptions.push(vscode.commands.registerCommand('void.discardDiff', async (params) => {
-		approvalCodeLensProvider.discardDiff(params)
-	}));
-
-	context.subscriptions.push(vscode.commands.registerCommand('void.openSettings', async () => {
-		vscode.commands.executeCommand('workbench.action.openSettings', '@ext:void.void');
-	}));
-
-	// 5.
-	webviewProvider.webview.then(
-		webview => {
-
-			// when config changes, send it to the sidebar
-			vscode.workspace.onDidChangeConfiguration(e => {
-				if (e.affectsConfiguration('void')) {
-					const apiConfig = getApiConfig()
-					webview.postMessage({ type: 'apiConfig', apiConfig } satisfies WebviewMessage)
-				}
-			})
-
-
-			// Receive messages in the extension from the sidebar webview (messages are sent using `postMessage`)
-			webview.onDidReceiveMessage(async (m: WebviewMessage) => {
-
-				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 WebviewMessage)
-
-				}
-				else if (m.type === 'applyCode') {
-
-					const editor = vscode.window.activeTextEditor
-					if (!editor) {
-						vscode.window.showInformationMessage('No active editor!')
-						return
-					}
-					const oldContents = await readFileContentOfUri(editor.document.uri)
-					const suggestedEdits = getDiffedLines(oldContents, m.code)
-					await approvalCodeLensProvider.addNewApprovals(editor, suggestedEdits)
-				}
-				else if (m.type === 'getApiConfig') {
-
-					const apiConfig = getApiConfig()
-					console.log('Api config:', apiConfig)
-
-					webview.postMessage({ type: 'apiConfig', apiConfig } satisfies WebviewMessage)
-
-				}
-				else {
-					console.error('unrecognized command', m.type, 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/getDiffedLines.ts

@@ -1,91 +0,0 @@
-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,39 +0,0 @@
-
-import * as vscode from 'vscode';
-import { ApiConfig } from './common/sendLLMMessage';
-
-// a selection is a frozen snapshot
-type Selection = { selectionStr: string, selectionRange: vscode.Range, filePath: vscode.Uri }
-
-type File = { filepath: vscode.Uri, content: string }
-
-type WebviewMessage = (
-
-	// editor -> sidebar
-	| { type: 'ctrl+l', selection: Selection } // user presses ctrl+l in the editor
-
-	// sidebar -> editor
-	| { type: 'applyCode', code: string } // user clicks "apply" in the sidebar
-
-	// sidebar -> editor
-	| { type: 'requestFiles', filepaths: vscode.Uri[] }
-
-	// editor -> sidebar
-	| { type: 'files', files: { filepath: vscode.Uri, content: string }[] }
-
-	// sidebar -> editor
-	| { type: 'getApiConfig' }
-
-	// editor -> sidebar
-	| { type: 'apiConfig', apiConfig: ApiConfig }
-
-)
-
-type Command = WebviewMessage['type']
-
-export {
-	Selection,
-	File,
-	WebviewMessage,
-	Command,
-}

extensions/void/src/sidebar/MarkdownRender.tsx

@@ -1,160 +0,0 @@
-import React, { JSX, useState } from 'react';
-import { MarkedToken, Token, TokensList } from 'marked';
-import { awaitVSCodeResponse, getVSCodeAPI } from './getVscodeApi';
-
-
-// code block with Apply button at top
-export const BlockCode = ({ text, disableApplyButton = false }: { text: string, disableApplyButton?: boolean }) => {
-	return <div className='py-1'>
-		{disableApplyButton ? null : <div className='text-sm'>
-			<button className='btn btn-secondary px-3 py-1 text-sm rounded-t-sm'
-				onClick={async () => { getVSCodeAPI().postMessage({ type: 'applyCode', code: text }) }}>Apply</button>
-		</div>}
-		<div className={`overflow-x-auto rounded-sm text-vscode-editor-fg bg-vscode-editor-bg ${disableApplyButton ? '' : 'rounded-tl-none'}`}>
-			<pre className='p-3'>
-				{text}
-			</pre>
-		</div>
-	</div>
-}
-
-const Render = ({ token }: { token: Token }) => {
-
-	// deal with built-in tokens first (assume marked token)
-	const t = token as MarkedToken
-
-	if (t.type === "space") {
-		return <span>{t.raw}</span>;
-	}
-
-	if (t.type === "code") {
-		return <BlockCode text={t.text} />
-	}
-
-	if (t.type === "heading") {
-		const HeadingTag = `h${t.depth}` as keyof JSX.IntrinsicElements;
-		return <HeadingTag>{t.text}</HeadingTag>;
-	}
-
-	if (t.type === "table") {
-		return (
-			<table>
-				<thead>
-					<tr>
-						{t.header.map((cell: any, index: number) => (
-							<th key={index} style={{ textAlign: t.align[index] || 'left' }}>
-								{cell.raw}
-							</th>
-						))}
-					</tr>
-				</thead>
-				<tbody>
-					{t.rows.map((row: any[], rowIndex: number) => (
-						<tr key={rowIndex}>
-							{row.map((cell: any, cellIndex: number) => (
-								<td key={cellIndex} style={{ textAlign: t.align[cellIndex] || 'left' }}>
-									{cell.raw}
-								</td>
-							))}
-						</tr>
-					))}
-				</tbody>
-			</table>
-		);
-	}
-
-	if (t.type === "hr") {
-		return <hr />;
-	}
-
-	if (t.type === "blockquote") {
-		return <blockquote>{t.text}</blockquote>;
-	}
-
-	if (t.type === "list") {
-
-		const ListTag = t.ordered ? 'ol' : 'ul';
-		return (
-			<ListTag start={t.start !== '' ? t.start : undefined}
-				className={`list-inside ${t.ordered ? 'list-decimal' : 'list-disc'}`}
-			>
-				{t.items.map((item, index) => (
-					<li key={index}>
-						{item.task && (
-							<input type="checkbox" checked={item.checked} readOnly />
-						)}
-						{item.text}
-					</li>
-				))}
-			</ListTag>
-		);
-	}
-
-	if (t.type === "paragraph") {
-		return <p>
-			{t.tokens.map((token, index) => (
-				<Render key={index} token={token} />
-			))}
-		</p>;
-	}
-
-	if (t.type === "html") {
-		return <pre>{`<html>`}{t.raw}{`</html>`}</pre>;
-	}
-
-	if (t.type === "text" || t.type === "escape") {
-		return <span>{t.raw}</span>;
-	}
-
-	if (t.type === "def") {
-		return null; // Definitions are typically not rendered
-	}
-
-	if (t.type === "link") {
-		return <a href={t.href} title={t.title ?? undefined}>{t.text}</a>;
-	}
-
-	if (t.type === "image") {
-		return <img src={t.href} alt={t.text} title={t.title ?? undefined} />;
-	}
-
-	if (t.type === "strong") {
-		return <strong>{t.text}</strong>;
-	}
-
-	if (t.type === "em") {
-		return <em>{t.text}</em>;
-	}
-
-	// inline code
-	if (t.type === "codespan") {
-		return <code className='text-vscode-editor-fg bg-vscode-editor-bg px-1 rounded-sm font-mono'>{t.text}</code>;
-	}
-
-	if (t.type === "br") {
-		return <br />;
-	}
-
-	if (t.type === "del") {
-		return <del>{t.text}</del>;
-	}
-
-
-	// default
-	return <div className='bg-orange-50 rounded-sm overflow-hidden'>
-		<span className='text-xs text-orange-500'>Unknown type:</span>
-		{t.raw}
-	</div>;
-};
-
-const MarkdownRender = ({ tokens }: { tokens: TokensList }) => {
-	return (
-		<>
-			{tokens.map((token, index) => (
-				<Render key={index} token={token} />
-			))}
-		</>
-	);
-};
-
-export default MarkdownRender;

extensions/void/src/sidebar/Sidebar.tsx

@@ -1,324 +0,0 @@
-import React, { useState, ChangeEvent, useEffect, useRef, useCallback, FormEvent } from "react"
-import { ApiConfig, LLMMessage, sendLLMMessage } from "../common/sendLLMMessage"
-import { Command, File, Selection, WebviewMessage } from "../shared_types"
-import { awaitVSCodeResponse, getVSCodeAPI, resolveAwaitingVSCodeResponse } from "./getVscodeApi"
-
-import { marked } from 'marked';
-import MarkdownRender, { BlockCode } from "./MarkdownRender";
-
-import * as vscode from 'vscode'
-
-
-const filesStr = (fullFiles: File[]) => {
-	return fullFiles.map(({ filepath, content }) =>
-		`
-${filepath.fsPath}
-\`\`\`
-${content}
-\`\`\``).join('\n')
-}
-
-const userInstructionsStr = (instructions: string, files: File[], selection: Selection | null) => {
-	return `
-${filesStr(files)}
-
-${!selection ? '' : `
-I am currently selecting this code:
-\`\`\`${selection.selectionStr}\`\`\`
-`}
-
-Please edit the code following these instructions:
-${instructions}
-
-If you make a change, rewrite the entire file.
-`; // TODO don't rewrite the whole file on prompt, instead rewrite it when click Apply
-}
-
-
-const FilesSelector = ({ files, setFiles }: { files: vscode.Uri[], setFiles: (files: vscode.Uri[]) => void }) => {
-	return files.length !== 0 && <div className='my-2'>
-		Include files:
-		{files.map((filename, i) =>
-			<div key={i} className='flex'>
-				{/* X button on a file */}
-				<button type='button' onClick={() => {
-					let file_index = files.indexOf(filename)
-					setFiles([...files.slice(0, file_index), ...files.slice(file_index + 1, Infinity)])
-				}}>
-					-{' '}<span className='text-gray-500'>{getBasename(filename.fsPath)}</span>
-				</button>
-			</div>
-		)}
-	</div>
-}
-
-const IncludedFiles = ({ files }: { files: vscode.Uri[] }) => {
-	return files.length !== 0 && <div className='text-xs my-2'>
-		{files.map((filename, i) =>
-			<div key={i} className='flex'>
-				<button type='button'
-					className='btn btn-secondary pointer-events-none'
-					onClick={() => {
-						// TODO redirect to the document filename.fsPath, when add this remove pointer-events-none
-					}}>
-					-{' '}<span className='text-gray-100'>{getBasename(filename.fsPath)}</span>
-				</button>
-			</div>
-		)}
-	</div>
-}
-
-
-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 = <>
-			<IncludedFiles files={chatMessage.files} />
-			{chatMessage.selection?.selectionStr && <BlockCode text={chatMessage.selection.selectionStr} disableApplyButton={true} />}
-			{children}
-		</>
-	}
-	else if (role === 'assistant') {
-		const tokens = marked.lexer(children); // https://marked.js.org/using_pro#renderer
-		chatbubbleContents = <MarkdownRender tokens={tokens} /> // 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>
-}
-
-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]
-}
-
-type ChatMessage = {
-	role: 'user'
-	content: string, // content sent to the llm
-	displayContent: string, // content displayed to user
-	selection: Selection | 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)
-}
-
-
-// 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
-}
-
-
-
-const Sidebar = () => {
-
-	// state of current message
-	const [selection, setSelection] = useState<Selection | 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 [chatMessageHistory, setChatHistory] = useState<ChatMessage[]>([])
-	const [messageStream, setMessageStream] = useState('')
-	const [isLoading, setIsLoading] = useState(false)
-
-	const abortFnRef = useRef<(() => void) | null>(null)
-
-	const [apiConfig, setApiConfig] = useState<ApiConfig | null>(null)
-
-	// get Api Config on mount
-	useEffect(() => {
-		getVSCodeAPI().postMessage({ type: 'getApiConfig' })
-	}, [])
-
-	// Receive messages from the extension
-	useEffect(() => {
-		const listener = (event: MessageEvent) => {
-
-			const m = event.data as WebviewMessage;
-			// resolve any awaiting promises
-			// eg. it will resolve the promise below for `await VSCodeResponse('files')`
-			resolveAwaitingVSCodeResponse(m)
-
-			// if user pressed ctrl+l, add their selection to the sidebar
-			if (m.type === 'ctrl+l') {
-
-				setSelection(m.selection)
-
-				const filepath = m.selection.filePath
-
-				// add file if it's not a duplicate
-				if (!files.find(f => f.fsPath === filepath.fsPath)) setFiles(files => [...files, filepath])
-
-			}
-			// when get apiConfig, set
-			else if (m.type === 'apiConfig') {
-				setApiConfig(m.apiConfig)
-			}
-
-		}
-		window.addEventListener('message', listener);
-		return () => { window.removeEventListener('message', listener) }
-	}, [files, selection])
-
-
-	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
-		setSelection(null)
-		setFiles([])
-
-		// 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 content = userInstructionsStr(instructions, relevantFiles.files, selection)
-		// console.log('prompt:\n', content)
-		const newHistoryElt: ChatMessage = { role: 'user', content, displayContent: instructions, selection, files }
-		setChatHistory(chatMessageHistory => [...chatMessageHistory, newHistoryElt])
-
-		// send message to claude
-		let { abort } = sendLLMMessage({
-			messages: [...chatMessageHistory.map(m => ({ role: m.role, content: m.content })), { role: 'user', content }],
-			onText: (newText, fullText) => setMessageStream(fullText),
-			onFinalMessage: (content) => {
-
-				// add assistant's message to chat history
-				const newHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content, }
-				setChatHistory(chatMessageHistory => [...chatMessageHistory, newHistoryElt])
-
-				// clear selection
-				setMessageStream('')
-				setIsLoading(false)
-			},
-			apiConfig: apiConfig
-		})
-		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 }
-		setChatHistory(chatMessageHistory => [...chatMessageHistory, newHistoryElt])
-
-		setMessageStream('')
-		setIsLoading(false)
-
-	}, [messageStream])
-
-	//Clear code selection
-	const clearSelection = () => {
-		setSelection(null);
-	};
-
-	return <>
-		<div className="flex flex-col h-screen w-full">
-			<div className="overflow-y-auto overflow-x-hidden space-y-4">
-				{/* previous messages */}
-				{chatMessageHistory.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">
-					{/* selected files */}
-					<FilesSelector files={files} setFiles={setFiles} />
-					{/* selected code */}
-					{!selection?.selectionStr ? null
-						: (
-							<div className="relative">
-								<button
-									onClick={clearSelection}
-									className="absolute top-2 right-2 text-white hover:text-gray-300 z-10"
-								>
-									X
-								</button>
-								<BlockCode text={selection.selectionStr} disableApplyButton={true} />
-							</div>
-						)}
-				</div>
-				<form
-					ref={formRef}
-					className="flex flex-row items-center rounded-md p-2 input"
-					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>
-
-	</>
-
-}
-
-export default Sidebar

extensions/void/src/sidebar/getVscodeApi.ts

@@ -1,54 +0,0 @@
-import { Command, WebviewMessage } from "../shared_types";
-
-
-
-// message -> res[]
-const awaiting: { [c in Command]: ((res: any) => void)[] } = {
-	"ctrl+l": [],
-	"applyCode": [],
-	"requestFiles": [],
-	"files": [],
-	"apiConfig": [],
-	"getApiConfig": [],
-}
-
-// use this function to await responses
-export const awaitVSCodeResponse = <C extends Command>(c: C) => {
-	let result: Promise<WebviewMessage & { type: C }> = new Promise((res, rej) => {
-		awaiting[c].push(res)
-	})
-	return result
-}
-
-export const resolveAwaitingVSCodeResponse = (m: WebviewMessage) => {
-	// resolve all promises for this message
-	for (let res of awaiting[m.type]) {
-		res(m)
-		awaiting[m.type].splice(0) // clear the array
-	}
-}
-
-
-// VS Code exposes the function acquireVsCodeApi() to us, it should only get called once
-let vsCodeApi: ReturnType<AcquireVsCodeApiType> | undefined;
-
-type AcquireVsCodeApiType = () => {
-	postMessage(message: WebviewMessage): void;
-	// setState(state: any): void; // getState and setState are made obsolete by us using { retainContextWhenHidden: true }
-	// getState(): any;
-};
-
-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,16 +0,0 @@
-import * as React from 'react'
-import * as ReactDOM from 'react-dom/client'
-import Sidebar from './Sidebar'
-
-// 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('root Element', rootElement)
-const root = ReactDOM.createRoot(rootElement)
-root.render(<Sidebar />)
-
-
-

extensions/void/src/sidebar/styles.css

@@ -1,35 +0,0 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-html {
-    font-size: var(--vscode-font-size);
-}
-
-.btn {
-    @apply cursor-pointer transition-colors;
-
-    &.btn-primary {
-        @apply bg-vscode-button-bg text-vscode-button-fg;
-
-        &:not(:disabled) {
-            @apply hover:bg-vscode-button-hoverBg;
-        }
-    }
-
-    &.btn-secondary {
-        @apply bg-vscode-button-secondary-bg text-vscode-button-secondary-fg;
-
-        &:not(:disabled) {
-            @apply hover:bg-vscode-button-secondary-hoverBg;
-        }
-    }
-
-    &:disabled {
-        @apply opacity-75 cursor-not-allowed;
-    }
-}
-
-.input {
-    @apply bg-vscode-input-bg text-vscode-input-fg border-vscode-input-border;
-}

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,26 +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: {
-					'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)",
-				},
-			},
-		},
-	},
-	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

@@ -75,6 +75,8 @@
     "@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 +87,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 +99,19 @@
     "@xterm/addon-webgl": "^0.19.0-beta.64",
     "@xterm/headless": "^5.6.0-beta.64",
     "@xterm/xterm": "^5.6.0-beta.64",
+    "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",
     "open": "^8.4.2",
+    "posthog-node": "^4.3.1",
     "tas-client-umd": "0.2.0",
     "v8-inspect-profiler": "^0.1.1",
     "vscode-oniguruma": "1.7.0",
@@ -115,16 +121,22 @@
     "yazl": "^2.4.3"
   },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.32.1",
+    "@google/generative-ai": "^0.21.0",
     "@playwright/test": "^1.46.1",
     "@swc/core": "1.3.62",
     "@types/cookie": "^0.3.3",
     "@types/debug": "^4.1.5",
+    "@types/diff": "^6.0.0",
     "@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",
@@ -156,6 +168,7 @@
     "cssnano": "^6.0.3",
     "debounce": "^1.0.0",
     "deemon": "^1.8.0",
+    "diff": "^7.0.0",
     "electron": "30.5.1",
     "eslint": "8.36.0",
     "eslint-plugin-header": "3.1.1",
@@ -190,6 +203,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",
@@ -198,7 +212,10 @@
     "mocha-junit-reporter": "^2.2.1",
     "mocha-multi-reporters": "^1.5.1",
     "npm-run-all": "^4.1.5",
+    "ollama": "^0.5.9",
+    "openai": "^4.71.1",
     "opn": "^6.0.0",
+    "original-fs": "^1.2.0",
     "os-browserify": "^0.3.0",
     "p-all": "^1.0.0",
     "path-browserify": "^1.0.1",
@@ -206,16 +223,22 @@
     "postcss-nesting": "^12.0.2",
     "pump": "^1.0.1",
     "rcedit": "^1.1.0",
-    "rimraf": "^2.2.8",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-syntax-highlighter": "^15.6.1",
+    "rimraf": "^2.7.1",
+    "scope-tailwind": "^1.0.1",
     "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",

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/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,13 @@ export class CodeApplication extends Disposable {
 		mainProcessElectronServer.registerChannel('logger', loggerChannel);
 		sharedProcessClient.then(client => client.registerChannel('logger', loggerChannel));
 
+		// Void
+		const metricsChannel = ProxyChannel.fromService(accessor.get(IMetricsService), disposables);
+		mainProcessElectronServer.registerChannel('void-channel-metrics', metricsChannel);
+
+		const sendLLMMessageChannel = new LLMMessageChannel(accessor.get(IMetricsService));
+		mainProcessElectronServer.registerChannel('void-channel-sendLLMMessage', sendLLMMessageChannel);
+
 		// 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,130 @@
+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';
+
+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/platform/void/browser/llmMessageService.ts

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ProxyOnTextPayload, ProxyOnErrorPayload, ProxyOnFinalMessagePayload, LLMMessageServiceParams, ProxyLLMMessageParams, ProxyLLMMessageAbortParams } from '../common/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 { IDisposable } from '../../../base/common/lifecycle.js';
+
+
+// BROWSER IMPLEMENTATION OF SENDLLMMESSAGE
+export const ISendLLMMessageService = createDecorator<ISendLLMMessageService>('sendLLMMessageService');
+
+// defines an interface that node/ creates and browser/ uses
+export interface ISendLLMMessageService {
+	readonly _serviceBrand: undefined;
+	sendLLMMessage: (params: LLMMessageServiceParams) => string;
+	abort: (requestId: string) => void;
+}
+
+
+export class SendLLMMessageService implements ISendLLMMessageService {
+
+	readonly _serviceBrand: undefined;
+	private readonly channel: IChannel;
+
+	private readonly _disposablesOfRequestId: Record<string, IDisposable[]> = {}
+
+	constructor(
+		@IMainProcessService mainProcessService: IMainProcessService // used as a renderer (only usable on client side)
+	) {
+
+		this.channel = mainProcessService.getChannel('void-channel-sendLLMMessage')
+		// const service = ProxyChannel.toService<LLMMessageChannel>(mainProcessService.getChannel('void-channel-sendLLMMessage')); // lets you call it like a service, not needed here
+	}
+
+	_addDisposable(requestId: string, disposable: IDisposable) {
+		if (!this._disposablesOfRequestId[requestId]) {
+			this._disposablesOfRequestId[requestId] = []
+		}
+		this._disposablesOfRequestId[requestId].push(disposable)
+	}
+
+
+
+	sendLLMMessage(params: LLMMessageServiceParams) {
+		const requestId_ = generateUuid();
+		const { onText, onFinalMessage, onError, ...proxyParams } = params;
+
+		// listen for listenerName='onText' | 'onFinalMessage' | 'onError', and call the original function on it
+
+		const onTextEvent: Event<ProxyOnTextPayload> = this.channel.listen('onText')
+		this._addDisposable(requestId_,
+			onTextEvent(e => {
+				if (requestId_ !== e.requestId) return;
+				onText(e)
+			})
+		)
+
+		const onFinalMessageEvent: Event<ProxyOnFinalMessagePayload> = this.channel.listen('onFinalMessage')
+		this._addDisposable(requestId_,
+			onFinalMessageEvent(e => {
+				if (requestId_ !== e.requestId) return;
+				onFinalMessage(e)
+				this._dispose(requestId_)
+			})
+		)
+
+		const onErrorEvent: Event<ProxyOnErrorPayload> = this.channel.listen('onError')
+		this._addDisposable(requestId_,
+			onErrorEvent(e => {
+				if (requestId_ !== e.requestId) return;
+				console.log('event onError', JSON.stringify(e))
+				onError(e)
+				this._dispose(requestId_)
+			})
+		)
+
+		// params will be stripped of all its functions
+		this.channel.call('sendLLMMessage', { ...proxyParams, requestId: requestId_ } satisfies ProxyLLMMessageParams);
+
+		return requestId_
+	}
+
+	private _dispose(requestId: string) {
+		if (!(requestId in this._disposablesOfRequestId)) return
+		for (const disposable of this._disposablesOfRequestId[requestId]) {
+			disposable.dispose()
+		}
+		delete this._disposablesOfRequestId[requestId]
+	}
+
+	abort(requestId: string) {
+		this.channel.call('abort', { requestId } satisfies ProxyLLMMessageAbortParams);
+		this._dispose(requestId)
+	}
+}
+
+registerSingleton(ISendLLMMessageService, SendLLMMessageService, InstantiationType.Delayed);
+

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

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+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 { IMetricsService } from '../common/metricsService.js';
+
+// BROWSER IMPLEMENTATION, calls channel
+
+export class MetricsService implements IMetricsService {
+
+	readonly _serviceBrand: undefined;
+	private readonly channel: IChannel;
+
+	constructor(
+		@IMainProcessService mainProcessService: IMainProcessService // (only usable on client side)
+	) {
+		this.channel = mainProcessService.getChannel('void-channel-metrics')
+	}
+
+	// call capture on the channel
+	capture(...params: Parameters<IMetricsService['capture']>) {
+		this.channel.call('capture', params);
+	}
+
+}
+
+registerSingleton(IMetricsService, MetricsService, InstantiationType.Eager);
+

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

@@ -0,0 +1,210 @@
+
+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 nonDefaultConfigFields = [
+	'anthropic',
+	'openAI',
+	'gemini',
+	'greptile',
+	'groq',
+	'ollama',
+	'openRouter',
+	'openAICompatible',
+	'azure',
+] as const
+
+
+
+export const voidConfigInfo: Record<
+	typeof nonDefaultConfigFields[number] | 'default', {
+		[prop: string]: {
+			description: string;
+			enumArr?: readonly string[] | undefined;
+			defaultVal: string;
+		};
+	}
+> = {
+	default: {
+		whichApi: configEnum(
+			'API Provider.',
+			'anthropic',
+			nonDefaultConfigFields,
+		),
+
+		maxTokens: configEnum(
+			'Max number of tokens to output.',
+			'1024',
+			[
+				'default', // this will be parseInt'd into NaN and ignored by the API. Anything that's not a number has this behavior.
+				'1024',
+				'2048',
+				'4096',
+				'8192'
+			] as const,
+		),
+
+	},
+	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,
+		),
+	},
+	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'),
+	},
+	groq: {
+		apikey: configString('Groq API key.', ''),
+		model: configEnum(
+			'Groq model to use.',
+			'mixtral-8x7b-32768',
+			[
+				"mixtral-8x7b-32768",
+				"llama2-70b-4096",
+				"gemma-7b-it"
+			] as const
+		),
+	},
+	ollama: {
+		endpoint: configString(
+			'The endpoint of your Ollama instance. Start Ollama by running `OLLAMA_ORIGINS="vscode - webview://*" ollama serve`.',
+			'http://127.0.0.1:11434'
+		),
+		model: configEnum(
+			'Ollama model to use.',
+			'codestral',
+			['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'] as const
+		),
+	},
+	openRouter: {
+		model: configString(
+			'OpenRouter model to use.',
+			'openai/gpt-4o'
+		),
+		apikey: configString('OpenRouter API key.', ''),
+	},
+	openAICompatible: {
+		endpoint: configString('The baseUrl (exluding /chat/completions).', '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.'
+		// 		}
+		// 	}
+		// },
+	},
+	gemini: {
+		apikey: configString('Google API key.', ''),
+		model: configEnum(
+			'Gemini model to use.',
+			'gemini-1.5-flash',
+			[
+				'gemini-1.5-flash',
+				'gemini-1.5-pro',
+				'gemini-1.5-flash-8b',
+				'gemini-1.0-pro'
+			] as const
+		),
+	},
+}
+
+
+// this is the type that comes with metadata like desc, default val, etc
+export 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']
+	}
+}

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

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { VoidConfig } from './configTypes.js'
+
+
+// ---------- type definitions ----------
+
+export type OnText = (p: { newText: string, fullText: string }) => void
+
+export type OnFinalMessage = (p: { fullText: string }) => void
+
+export type OnError = (p: { error: Error | string }) => void
+
+export type AbortRef = { current: (() => void) | null }
+
+export type LLMMessage = {
+	role: 'system' | 'user' | 'assistant';
+	content: string;
+}
+
+export type LLMMessageServiceParams = {
+	onText: OnText;
+	onFinalMessage: OnFinalMessage;
+	onError: OnError;
+
+	messages: LLMMessage[];
+	voidConfig: VoidConfig | null;
+
+	logging: {
+		loggingName: string,
+	};
+}
+
+export type SendLLMMMessageParams = {
+	onText: OnText;
+	onFinalMessage: OnFinalMessage;
+	onError: OnError;
+
+	messages: LLMMessage[];
+	voidConfig: VoidConfig | null;
+
+	logging: {
+		loggingName: string,
+	};
+	abortRef: AbortRef;
+}
+
+// can't send functions across a proxy, use listeners instead
+export const listenerNames = ['onText', 'onFinalMessage', 'onError'] as const
+export type ProxyLLMMessageParams = Omit<LLMMessageServiceParams, typeof listenerNames[number]> & { requestId: string }
+
+export type ProxyOnTextPayload = Parameters<OnText>[0] & { requestId: string }
+export type ProxyOnFinalMessagePayload = Parameters<OnFinalMessage>[0] & { requestId: string }
+export type ProxyOnErrorPayload = Parameters<OnError>[0] & { requestId: string }
+
+export type ProxyLLMMessageAbortParams = { requestId: string }

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

@@ -0,0 +1,10 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+export interface IMetricsService {
+	readonly _serviceBrand: undefined;
+	capture(event: string, params: Record<string, any>): void;
+}
+
+export const IMetricsService = createDecorator<IMetricsService>('metricsService');
+
+

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

@@ -0,0 +1,57 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { parseMaxTokensStr, SendLLMMessageFnTypeInternal } from './util.js';
+
+// Anthropic
+type LLMMessageAnthropic = {
+	role: 'user' | 'assistant';
+	content: string;
+}
+export const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter }) => {
+
+	const thisConfig = voidConfig.anthropic
+
+	const anthropic = new Anthropic({ apiKey: thisConfig.apikey, dangerouslyAllowBrowser: true }); // defaults to process.env["ANTHROPIC_API_KEY"]
+
+	// 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: thisConfig.model,
+		max_tokens: parseMaxTokensStr(voidConfig.default.maxTokens)!, // this might be undefined, but it will just throw an error for the user
+	});
+
+
+	// 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({ error: 'Invalid API key.' })
+		}
+		else {
+			onError({ error })
+		}
+	})
+
+	// 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,48 @@
+import { Content, GoogleGenerativeAI, GoogleGenerativeAIFetchError } from '@google/generative-ai';
+import { SendLLMMessageFnTypeInternal } from './util';
+
+// Gemini
+export const sendGeminiMsg: SendLLMMessageFnTypeInternal = async ({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter }) => {
+
+	let fullText = ''
+
+	const thisConfig = voidConfig.gemini
+
+	const genAI = new GoogleGenerativeAI(thisConfig.apikey);
+	const model = genAI.getGenerativeModel({ model: thisConfig.model });
+
+	// 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({ error: 'Invalid API key.' });
+			}
+			else {
+				onError({ error });
+			}
+		})
+}

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

@@ -0,0 +1,64 @@
+
+// Greptile
+// https://docs.greptile.com/api-reference/query
+// https://docs.greptile.com/quickstart#sample-response-streamed
+
+import { SendLLMMessageFnTypeInternal } from './util';
+
+export const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter }) => {
+
+	let fullText = ''
+
+	const thisConfig = voidConfig.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,40 @@
+import Groq from 'groq-sdk';
+import { SendLLMMessageFnTypeInternal } from './util';
+import { parseMaxTokensStr } from './util.js';
+
+// Groq
+export const sendGroqMsg: SendLLMMessageFnTypeInternal = async ({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter }) => {
+	let fullText = '';
+
+	const groq = new Groq({
+		apiKey: voidConfig.groq.apikey,
+		dangerouslyAllowBrowser: true
+	});
+
+	await groq.chat.completions
+		.create({
+			messages: messages,
+			model: voidConfig.groq.model,
+			stream: true,
+			temperature: 0.7,
+			max_tokens: parseMaxTokensStr(voidConfig.default.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({ error });
+		})
+
+
+};

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

@@ -0,0 +1,47 @@
+import { Ollama, ErrorResponse } from 'ollama';
+import { SendLLMMessageFnTypeInternal } from './util';
+import { parseMaxTokensStr } from './util.js';
+
+// Ollama
+export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter }) => {
+
+	const thisConfig = voidConfig.ollama
+
+	let fullText = ''
+
+	const ollama = new Ollama({ host: thisConfig.endpoint })
+
+	ollama.chat({
+		model: thisConfig.model,
+		messages: messages,
+		stream: true,
+		options: { num_predict: parseMaxTokensStr(voidConfig.default.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({ error })
+		})
+
+};
+
+
+

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

@@ -0,0 +1,64 @@
+import OpenAI from 'openai';
+import { SendLLMMessageFnTypeInternal } from './util';
+import { parseMaxTokensStr } from './util.js';
+
+
+// OpenAI, OpenRouter, OpenAICompatible
+export const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter }) => {
+
+	let fullText = ''
+
+	let openai: OpenAI
+	let options: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
+
+	const maxTokens = parseMaxTokensStr(voidConfig.default.maxTokens)
+
+	if (voidConfig.default.whichApi === 'openAI') {
+		const thisConfig = voidConfig.openAI
+		openai = new OpenAI({ apiKey: thisConfig.apikey, dangerouslyAllowBrowser: true });
+		options = { model: thisConfig.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
+	}
+	else if (voidConfig.default.whichApi === 'openRouter') {
+		const thisConfig = voidConfig.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: thisConfig.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
+	}
+	else if (voidConfig.default.whichApi === 'openAICompatible') {
+		const thisConfig = voidConfig.openAICompatible
+		openai = new OpenAI({ baseURL: thisConfig.endpoint, apiKey: thisConfig.apikey, dangerouslyAllowBrowser: true })
+		options = { model: thisConfig.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
+	}
+	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 => {
+			_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({ error: 'Invalid API key.' });
+			}
+			else {
+				onError({ error });
+			}
+		})
+
+};

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

@@ -0,0 +1,109 @@
+import { SendLLMMMessageParams, OnText, OnFinalMessage, OnError } from '../../common/llmMessageTypes.js';
+import { IMetricsService } from '../../common/metricsService.js';
+
+import { sendAnthropicMsg } from './anthropic.js';
+import { sendGeminiMsg } from './gemini.js';
+import { sendGreptileMsg } from './greptile.js';
+import { sendGroqMsg } from './groq.js';
+import { sendOllamaMsg } from './ollama.js';
+import { sendOpenAIMsg } from './openai.js';
+
+
+export const sendLLMMessage = (
+	{
+		messages, onText: onText_, onFinalMessage: onFinalMessage_, onError: onError_,
+		abortRef: abortRef_, voidConfig, logging: { loggingName },
+	}: SendLLMMMessageParams,
+
+	metricsService: IMetricsService
+) => {
+	if (!voidConfig) return;
+
+	// 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, {
+			whichApi: voidConfig.default['whichApi'],
+			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 = ({ error }) => {
+		if (_didAbort) return
+		console.error('sendLLMMessage onError:', error)
+		captureChatEvent(`${loggingName} - Error`, { error })
+		onError_({ error })
+	}
+
+	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 (voidConfig.default.whichApi) {
+			case 'anthropic':
+				sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter, });
+				break;
+			case 'openAI':
+			case 'openRouter':
+			case 'openAICompatible':
+				sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter, });
+				break;
+			case 'gemini':
+				sendGeminiMsg({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter, });
+				break;
+			case 'ollama':
+				sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter, });
+				break;
+			case 'greptile':
+				sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter, });
+				break;
+			case 'groq':
+				sendGroqMsg({ messages, onText, onFinalMessage, onError, voidConfig, _setAborter, });
+				break;
+			default:
+				onError({ error: `Error: whichApi was "${voidConfig.default.whichApi}", which is not recognized!` })
+				break;
+		}
+	}
+
+	catch (error) {
+		if (error instanceof Error) { onError({ error }) }
+		else { onError({ error: `Unexpected Error in sendLLMMessage: ${error}` }); }
+		// ; (_aborter as any)?.()
+		// _didAbort = true
+	}
+
+
+
+}
+

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

@@ -0,0 +1,21 @@
+import { VoidConfig } from '../../common/configTypes'
+import { LLMMessage, OnText, OnFinalMessage, OnError } from '../../common/llmMessageTypes'
+
+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 type SendLLMMessageFnTypeInternal = (params: {
+	messages: LLMMessage[];
+	onText: OnText;
+	onFinalMessage: OnFinalMessage;
+	onError: OnError;
+	voidConfig: VoidConfig;
+
+	_setAborter: (aborter: () => void) => void;
+}) => void

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

@@ -0,0 +1,95 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 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 { listenerNames, ProxyOnTextPayload, ProxyOnErrorPayload, ProxyOnFinalMessagePayload, ProxyLLMMessageParams, AbortRef, SendLLMMMessageParams, ProxyLLMMessageAbortParams } from '../common/llmMessageTypes.js';
+import { sendLLMMessage } from './llmMessage/sendLLMMessage.js'
+import { IMetricsService } from '../common/metricsService.js';
+
+// NODE IMPLEMENTATION - calls actual sendLLMMessage() and returns listeners to it
+
+export class LLMMessageChannel implements IServerChannel {
+	private readonly _onText = new Emitter<ProxyOnTextPayload>();
+	readonly onText = this._onText.event;
+
+	private readonly _onFinalMessage = new Emitter<ProxyOnFinalMessagePayload>();
+	readonly onFinalMessage = this._onFinalMessage.event;
+
+	private readonly _onError = new Emitter<ProxyOnErrorPayload>();
+	readonly onError = this._onError.event;
+
+
+	private readonly _abortRefOfRequestId: Record<string, AbortRef> = {}
+
+
+	constructor(
+		private readonly metricsService: IMetricsService
+	) { }
+
+	// browser uses this to listen for changes
+	listen(_: unknown, event: typeof listenerNames[number]): Event<any> {
+		if (event === 'onText') {
+			return this.onText;
+		}
+		else if (event === 'onFinalMessage') {
+			return this.onFinalMessage;
+		}
+		else if (event === 'onError') {
+			return this.onError;
+		}
+		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 {
+				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 _callSendLLMMessage(params: ProxyLLMMessageParams) {
+		const { requestId } = params;
+
+		if (!(requestId in this._abortRefOfRequestId))
+			this._abortRefOfRequestId[requestId] = { current: null }
+
+		const mainThreadParams: SendLLMMMessageParams = {
+			...params,
+			onText: ({ newText, fullText }) => { this._onText.fire({ requestId, newText, fullText }); },
+			onFinalMessage: ({ fullText }) => { this._onFinalMessage.fire({ requestId, fullText }); },
+			onError: ({ error }) => { this._onError.fire({ requestId, error }); },
+			abortRef: this._abortRefOfRequestId[requestId],
+		}
+		sendLLMMessage(mainThreadParams, this.metricsService);
+	}
+
+	private _callAbort(params: ProxyLLMMessageAbortParams) {
+		const { requestId } = params;
+		if (!(requestId in this._abortRefOfRequestId)) return
+		this._abortRefOfRequestId[requestId].current?.()
+		delete this._abortRefOfRequestId[requestId]
+	}
+
+
+}

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

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 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.init('phc_UanIdujHiLp55BkUTjB1AuBXcasVkdqRwgnwRlWESH2', { api_host: 'https://us.i.posthog.com', })
+
+// const buildEnv = 'development';
+// const buildNumber = '1.0.0';
+// const isMac = process.platform === 'darwin';
+// // TODO use commandKey
+// const commandKey = isMac ? '⌘' : 'Ctrl';
+// const systemInfo = {
+// 	buildEnv,
+// 	buildNumber,
+// 	isMac,
+// }
+
+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) => {
+		console.log('Capturing', { event, params })
+		console.log('full capture:', { distinctId: this._distinctId, event, properties: params })
+		this.client.capture({ distinctId: this._distinctId, event, properties: params })
+	}
+}
+
+

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

@@ -741,8 +741,24 @@ export class CodeWindow extends BaseWindow implements ICodeWindow {
 
 			cb({ cancel: false, requestHeaders: Object.assign(details.requestHeaders, headers) });
 		});
+
+
+		// // Void: send from https://
+		// this._win.webContents.session.webRequest.onBeforeSendHeaders({ urls }, async (details, cb) => {
+		// 	// const voidConfig = this.voidConfigStateService.state.voidConfig
+		// 	// const whichApi = voidConfig.default['whichApi']
+		// 	const endpoint = 'http://127.' //string | undefined = voidConfig[whichApi as VoidConfigField].endpoint
+
+		// 	if (endpoint && details.url.startsWith(endpoint)) {
+		// 		details.requestHeaders['Origin'] = 'https://app.voideditor.com'
+		// 	}
+		// 	cb({ cancel: false, requestHeaders: details.requestHeaders });
+		// });
 	}
 
+
+
+
 	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/contrib/void/browser/.gitignore

@@ -0,0 +1 @@
+void-imports/

src/vs/workbench/contrib/void/browser/findDiffs.ts

@@ -0,0 +1,276 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { diffLines } from './react/out/util/diffLines.js'
+
+export type ComputedDiff = {
+	type: 'edit';
+	originalCode: string;
+	originalStartLine: number;
+	originalEndLine: number;
+	code: string;
+	startLine: number; // 1-indexed
+	endLine: number;
+} | {
+	type: 'insertion';
+	// originalCode: string;
+	originalStartLine: number; // insertion starts on column 0 of this
+	// originalEndLine: number;
+	code: string;
+	startLine: number;
+	endLine: number;
+} | {
+	type: 'deletion';
+	originalCode: string;
+	originalStartLine: number;
+	originalEndLine: number;
+	// code: string;
+	startLine: number; // deletion starts on column 0 of this
+	// endLine: number;
+}
+
+export function findDiffs(oldStr: string, newStr: string) {
+
+	// this makes it so the end of the file always ends with a \n (if you don't have this, then diffing E vs E\n gives an "edit". With it, you end up diffing E\n vs E\n\n which now properly gives an insertion)
+	newStr += '\n';
+	oldStr += '\n';
+
+	// 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 = diffLines(oldStr, newStr);
+	lineByLineChanges.push({ value: '', added: false, removed: false }) // add a dummy so we flush any streaks we haven't yet at the very end (!line.added && !line.removed)
+
+	let oldFileLineNum: number = 1;
+	let newFileLineNum: number = 1;
+
+	let streakStartInNewFile: number | undefined = undefined
+	let streakStartInOldFile: number | undefined = undefined
+
+	const oldStrLines = ('\n' + oldStr).split('\n') // add newline so indexing starts at 1
+	const newStrLines = ('\n' + newStr).split('\n')
+
+	const replacements: ComputedDiff[] = []
+	for (const line of lineByLineChanges) {
+
+		// no change on this line
+		if (!line.added && !line.removed) {
+
+			// do nothing
+
+			// if we were on a streak of +s and -s, end it
+			if (streakStartInNewFile !== undefined) {
+				let type: 'edit' | 'insertion' | 'deletion' = 'edit'
+
+				const startLine = streakStartInNewFile
+				const endLine = newFileLineNum - 1 // don't include current line, the edit was up to this line but not including it
+
+				const originalStartLine = streakStartInOldFile!
+				const originalEndLine = oldFileLineNum - 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 originalContent = oldStrLines.slice(originalStartLine, originalEndLine + 1).join('\n')
+
+				// if the range is empty, mark it as a deletion / insertion (both won't be true at once)
+				// DELETION
+				if (endLine === startLine - 1) {
+					type = 'deletion'
+					// endLine = startLine
+				}
+
+				// INSERTION
+				else if (originalEndLine === originalStartLine - 1) {
+					type = 'insertion'
+					// originalEndLine = originalStartLine
+				}
+
+				const replacement: ComputedDiff = {
+					type,
+					startLine, endLine,
+					// startCol, endCol,
+					originalStartLine, originalEndLine,
+					// code: newContent,
+					// originalRange: new Range(originalStartLine, originalStartCol, originalEndLine, originalEndCol),
+					originalCode: originalContent,
+					code: newContent,
+				}
+
+				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 (or "count")
+		}
+
+		// 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 (or "count")
+		}
+	} // end for
+
+	// console.log('DIFF', { oldStr, newStr, replacements })
+	return replacements
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// // uncomment this to test
+// let name_ = ''
+// let testsFailed = 0
+// const assertEqual = (a: { [s: string]: any }, b: { [s: string]: any }) => {
+// 	let keys = new Set([...Object.keys(a), ...Object.keys(b)])
+// 	for (let k of keys) {
+// 		if (a[k] !== b[k]) {
+// 			console.error('Void Test Error:', name_, '\n', `${k}=`, `${JSON.stringify(a[k])}, ${JSON.stringify(b[k])}`)
+// 			// console.error(JSON.stringify(a, null, 4))
+// 			// console.error(JSON.stringify(b, null, 4))
+// 			testsFailed += 1
+// 		}
+// 	}
+// }
+// const test = (name: string, fn: () => void) => {
+// 	name_ = name
+// 	fn()
+// }
+
+// const originalCode = `\
+// A
+// B
+// C
+// D
+// E`
+
+// const insertedCode = `\
+// A
+// B
+// C
+// F
+// D
+// E`
+
+// const modifiedCode = `\
+// A
+// B
+// C
+// F
+// E`
+
+// const modifiedCode2 = `\
+// A
+// B
+// C
+// D
+// E
+// `
+
+
+// test('Diffs Insertion', () => {
+// 	const diffs = findDiffs(originalCode, insertedCode)
+
+// 	const expected: BaseDiff = {
+// 		type: 'insertion',
+// 		originalCode: '',
+// 		originalStartLine: 4, // empty range where the insertion happened
+// 		originalEndLine: 4,
+
+// 		startLine: 4,
+// 		startCol: 1,
+// 		endLine: 4,
+// 		endCol: Number.MAX_SAFE_INTEGER,
+// 	}
+// 	assertEqual(diffs[0], expected)
+// })
+
+// test('Diffs Deletion', () => {
+// 	const diffs = findDiffs(insertedCode, originalCode)
+// 	assertEqual({ length: diffs.length }, { length: 1 })
+// 	const expected: BaseDiff = {
+// 		type: 'deletion',
+// 		originalCode: 'F',
+// 		originalStartLine: 4,
+// 		originalEndLine: 4,
+
+// 		startLine: 4,
+// 		startCol: 1, // empty range where the deletion happened
+// 		endLine: 4,
+// 		endCol: 1,
+// 	}
+// 	assertEqual(diffs[0], expected)
+// })
+
+// test('Diffs Modification', () => {
+// 	const diffs = findDiffs(originalCode, modifiedCode)
+// 	assertEqual({ length: diffs.length }, { length: 1 })
+// 	const expected: BaseDiff = {
+// 		type: 'edit',
+// 		originalCode: 'D',
+// 		originalStartLine: 4,
+// 		originalEndLine: 4,
+
+// 		startLine: 4,
+// 		startCol: 1,
+// 		endLine: 4,
+// 		endCol: Number.MAX_SAFE_INTEGER,
+// 	}
+// 	assertEqual(diffs[0], expected)
+// })
+
+// test('Diffs Modification 2', () => {
+// 	const diffs = findDiffs(originalCode, modifiedCode2)
+// 	assertEqual({ length: diffs.length }, { length: 1 })
+// 	const expected: BaseDiff = {
+// 		type: 'insertion',
+// 		originalCode: '',
+// 		originalStartLine: 6,
+// 		originalEndLine: 6,
+
+// 		startLine: 6,
+// 		startCol: 1,
+// 		endLine: 6,
+// 		endCol: Number.MAX_SAFE_INTEGER,
+// 	}
+// 	assertEqual(diffs[0], expected)
+// })
+
+
+
+// if (testsFailed === 0) {
+// 	console.log('✅ Void - All tests passed')
+// }
+// else {
+// 	console.log('❌ Void - At least one test failed')
+// }

src/vs/workbench/contrib/void/browser/getCmdKey.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { OperatingSystem, OS } from '../../../../base/common/platform.js';
+
+export function getCmdKey(): string {
+	if (OS === OperatingSystem.Macintosh) {
+		return '⌘';
+	} else {
+		return 'Ctrl';
+	}
+}
+
+
+
+

src/vs/workbench/contrib/void/browser/media/void.css

@@ -0,0 +1,15 @@
+.monaco-editor .void-sweepIdxBG {
+	background-color: var(--vscode-void-sweepIdxBG);
+}
+
+.void-sweepBG {
+	background-color: var(--vscode-void-sweepBG);
+}
+
+.void-greenBG {
+	background-color: var(--vscode-void-greenBG);
+}
+
+.void-redBG {
+	background-color: var(--vscode-void-redBG);
+}

src/vs/workbench/contrib/void/browser/prompt/stringifyFiles.ts

@@ -0,0 +1,25 @@
+
+import { CodeSelection } from '../registerThreads.js';
+
+export const filesStr = (selections: CodeSelection[]) => {
+
+	return selections.map(({ fileURI, content, selectionStr }) =>
+		`\
+File: ${fileURI.fsPath}
+\`\`\`
+${content}
+\`\`\`${selectionStr === null ? '' : `
+Selection: ${selectionStr}`}
+`).join('\n')
+}
+
+
+export const userInstructionsStr = (instructions: string, selections: CodeSelection[] | null) => {
+	let str = '';
+	if (selections && selections.length > 0) {
+		str += filesStr(selections);
+		str += `Please edit the selected code following these instructions:\n`
+	}
+	str += `${instructions}`;
+	return str;
+};

src/vs/workbench/contrib/void/browser/prompt/systemPrompts.ts

@@ -0,0 +1,411 @@
+
+
+
+// // used for ctrl+l
+// const partialGenerationInstructions = ``
+
+
+// // used for ctrl+k, autocomplete
+// const fimInstructions = ``
+
+
+export const generateDiffInstructions = `
+You are a coding assistant. You are given a list of relevant files \`files\`, a selection that the user is making \`selection\`, and instructions to follow \`instructions\`.
+
+Please edit the selected file following the user's instructions (or, if appropriate, answer their question instead).
+
+All changes made to files must be outputted in unified diff format.
+Unified diff format instructions:
+1. Each diff must begin with \`\`\`@@ ... @@\`\`\`.
+2. Each line must start with a \`+\` or \`-\` or \` \` symbol.
+3. Make diffs more than a few lines.
+4. Make high-level diffs rather than many one-line diffs.
+
+Here's an example of unified diff format:
+
+\`\`\`
+@@ ... @@
+-def factorial(n):
+-    if n == 0:
+-        return 1
+-    else:
+-        return n * factorial(n-1)
++def factorial(number):
++    if number == 0:
++        return 1
++    else:
++        return number * factorial(number-1)
+\`\`\`
+
+Please create high-level diffs where you group edits together if they are near each other, like in the above example. Another way to represent the above example is to make many small line edits. However, this is less preferred, because the edits are not high-level. The edits are close together and should be grouped:
+
+\`\`\`
+@@ ... @@ # This is less preferred because edits are close together and should be grouped:
+-def factorial(n):
++def factorial(number):
+-    if n == 0:
++    if number == 0:
+         return 1
+     else:
+-        return n * factorial(n-1)
++        return number * factorial(number-1)
+\`\`\`
+
+# Example 1:
+
+FILES
+selected file \`test.ts\`:
+\`\`\`
+x = 1
+
+{{selection}}
+
+z = 3
+\`\`\`
+
+SELECTION
+\`\`\`const y = 2\`\`\`
+
+INSTRUCTIONS
+\`\`\`y = 3\`\`\`
+
+EXPECTED RESULT
+
+We should change the selection from \`\`\`y = 2\`\`\` to \`\`\`y = 3\`\`\`.
+\`\`\`
+@@ ... @@
+-x = 1
+-
+-y = 2
++x = 1
++
++y = 3
+\`\`\`
+
+# Example 2:
+
+FILES
+selected file \`Sidebar.tsx\`:
+\`\`\`
+import React from 'react';
+import styles from './Sidebar.module.css';
+
+interface SidebarProps {
+  items: { label: string; href: string }[];
+  onItemSelect?: (label: string) => void;
+  onExtraButtonClick?: () => void;
+}
+
+const Sidebar: React.FC<SidebarProps> = ({ items, onItemSelect, onExtraButtonClick }) => {
+  return (
+    <div className={styles.sidebar}>
+      <ul>
+        {items.map((item, index) => (
+          <li key={index}>
+             {{selection}}
+              className={styles.sidebarButton}
+              onClick={() => onItemSelect?.(item.label)}
+            >
+              {item.label}
+            </button>
+          </li>
+        ))}
+      </ul>
+      <button className={styles.extraButton} onClick={onExtraButtonClick}>
+        Extra Action
+      </button>
+    </div>
+  );
+};
+
+export default Sidebar;
+\`\`\`
+
+SELECTION
+\`\`\`             <button\`\`\`
+
+INSTRUCTIONS
+\`\`\`make all the buttons like this into divs\`\`\`
+
+EXPECTED OUTPUT
+
+We should change all the buttons like the one selected into a div component. Here is the change:
+\`\`\`
+@@ ... @@
+-<div className={styles.sidebar}>
+-<ul>
+-  {items.map((item, index) => (
+-	<li key={index}>
+-	  <button
+-		className={styles.sidebarButton}
+-		onClick={() => onItemSelect?.(item.label)}
+-	  >
+-		{item.label}
+-	  </button>
+-	</li>
+-  ))}
+-</ul>
+-<button className={styles.extraButton} onClick={onExtraButtonClick}>
+-  Extra Action
+-</button>
+-</div>
++<div className={styles.sidebar}>
++<ul>
++  {items.map((item, index) => (
++	<li key={index}>
++	  <div
++		className={styles.sidebarButton}
++		onClick={() => onItemSelect?.(item.label)}
++	  >
++		{item.label}
++	  </div>
++	</li>
++  ))}
++</ul>
++<div className={styles.extraButton} onClick={onExtraButtonClick}>
++  Extra Action
++</div>
++</div>
+\`\`\`
+`;
+
+
+export const searchDiffChunkInstructions = `
+You are a coding assistant that applies a diff to a file. You are given a diff \`diff\`, a list of files \`files\` to apply the diff to, and a selection \`selection\` that you are currently considering in the file.
+
+Determine whether you should modify ANY PART of the selection \`selection\` following the \`diff\`. Return \`true\` if you should modify any part of the selection, and \`false\` if you should not modify any part of it.
+
+# Example 1:
+
+FILES
+selected file \`Sidebar.tsx\`:
+\`\`\`
+import React from 'react';
+import styles from './Sidebar.module.css';
+
+interface SidebarProps {
+  items: { label: string; href: string }[];
+  onItemSelect?: (label: string) => void;
+  onExtraButtonClick?: () => void;
+}
+
+const Sidebar: React.FC<SidebarProps> = ({ items, onItemSelect, onExtraButtonClick }) => {
+  return (
+    <div className={styles.sidebar}>
+      <ul>
+        {items.map((item, index) => (
+          <li key={index}>
+            <button
+              className={styles.sidebarButton}
+              onClick={() => onItemSelect?.(item.label)}
+            >
+              {item.label}
+            </button>
+          </li>
+        ))}
+      </ul>
+      <button className={styles.extraButton} onClick={onExtraButtonClick}>
+        Extra Action
+      </button>
+    </div>
+  );
+};
+
+export default Sidebar;
+\`\`\`
+
+DIFF
+\`\`\`
+@@ ... @@
+-<div className={styles.sidebar}>
+-<ul>
+-  {items.map((item, index) => (
+-	<li key={index}>
+-	  <button
+-		className={styles.sidebarButton}
+-		onClick={() => onItemSelect?.(item.label)}
+-	  >
+-		{item.label}
+-	  </button>
+-	</li>
+-  ))}
+-</ul>
+-<button className={styles.extraButton} onClick={onExtraButtonClick}>
+-  Extra Action
+-</button>
+-</div>
++<div className={styles.sidebar}>
++<ul>
++  {items.map((item, index) => (
++	<li key={index}>
++	  <div
++		className={styles.sidebarButton}
++		onClick={() => onItemSelect?.(item.label)}
++	  >
++		{item.label}
++	  </div>
++	</li>
++  ))}
++</ul>
++<div className={styles.extraButton} onClick={onExtraButtonClick}>
++  Extra Action
++</div>
++</div>
+\`\`\`
+
+SELECTION
+\`\`\`
+import React from 'react';
+import styles from './Sidebar.module.css';
+
+interface SidebarProps {
+  items: { label: string; href: string }[];
+  onItemSelect?: (label: string) => void;
+  onExtraButtonClick?: () => void;
+}
+
+const Sidebar: React.FC<SidebarProps> = ({ items, onItemSelect, onExtraButtonClick }) => {
+  return (
+    <div className={styles.sidebar}>
+      <ul>
+        {items.map((item, index) => (
+\`\`\`
+
+RESULT
+The output should be \`true\` because the diff begins on the line with \`<div className={styles.sidebar}>\` and this line is present in the selection.
+
+OUTPUT
+\`true\`
+`
+
+
+export const writeFileWithDiffInstructions = `
+You are a coding assistant that applies a diff to a file. You are given the original file \`original_file\`, a diff \`diff\`, and a new file that you are applying the diff to \`new_file\`.
+
+Please finish writing the new file \`new_file\`, according to the diff \`diff\`. You must completely re-write the whole file, using the diff.
+
+Directions:
+1. Continue exactly where the new file \`new_file\` left off.
+2. Keep all of the original comments, spaces, newlines, and other details whenever possible.
+3. Note that \`+\` lines represent additions, \`-\` lines represent removals, and space lines \` \` represent no change.
+
+# Example 1:
+
+ORIGINAL_FILE
+\`Sidebar.tsx\`:
+\`\`\`
+import React from 'react';
+import styles from './Sidebar.module.css';
+
+interface SidebarProps {
+  items: { label: string; href: string }[];
+  onItemSelect?: (label: string) => void;
+  onExtraButtonClick?: () => void;
+}
+
+const Sidebar: React.FC<SidebarProps> = ({ items, onItemSelect, onExtraButtonClick }) => {
+  return (
+    <div className={styles.sidebar}>
+      <ul>
+        {items.map((item, index) => (
+          <li key={index}>
+            <button
+              className={styles.sidebarButton}
+              onClick={() => onItemSelect?.(item.label)}
+            >
+              {item.label}
+            </button>
+          </li>
+        ))}
+      </ul>
+      <button className={styles.extraButton} onClick={onExtraButtonClick}>
+        Extra Action
+      </button>
+    </div>
+  );
+};
+
+export default Sidebar;
+\`\`\`
+
+DIFF
+\`\`\`
+@@ ... @@
+-<div className={styles.sidebar}>
+-<ul>
+-  {items.map((item, index) => (
+-	<li key={index}>
+-	  <button
+-		className={styles.sidebarButton}
+-		onClick={() => onItemSelect?.(item.label)}
+-	  >
+-		{item.label}
+-	  </button>
+-	</li>
+-  ))}
+-</ul>
+-<button className={styles.extraButton} onClick={onExtraButtonClick}>
+-  Extra Action
+-</button>
+-</div>
++<div className={styles.sidebar}>
++<ul>
++  {items.map((item, index) => (
++	<li key={index}>
++	  <div
++		className={styles.sidebarButton}
++		onClick={() => onItemSelect?.(item.label)}
++	  >
++		{item.label}
++	  </div>
++	</li>
++  ))}
++</ul>
++<div className={styles.extraButton} onClick={onExtraButtonClick}>
++  Extra Action
++</div>
++</div>
+\`\`\`
+
+NEW_FILE
+\`\`\`
+import React from 'react';
+import styles from './Sidebar.module.css';
+
+interface SidebarProps {
+  items: { label: string; href: string }[];
+  onItemSelect?: (label: string) => void;
+  onExtraButtonClick?: () => void;
+}
+
+const Sidebar: React.FC<SidebarProps> = ({ items, onItemSelect, onExtraButtonClick }) => {
+  return (
+\`\`\`
+
+COMPLETION
+\`\`\`
+    <div className={styles.sidebar}>
+      <ul>
+        {items.map((item, index) => (
+          <li key={index}>
+            <div
+              className={styles.sidebarButton}
+              onClick={() => onItemSelect?.(item.label)}
+            >
+              {item.label}
+            </div>
+          </li>
+        ))}
+      </ul>
+      <div className={styles.extraButton} onClick={onExtraButtonClick}>
+        Extra Action
+      </div>
+    </div>
+  );
+};
+
+export default Sidebar;\`\`\`
+`
+
+
+

src/vs/workbench/contrib/void/browser/react/.gitignore

@@ -0,0 +1,2 @@
+out/
+src2/

src/vs/workbench/contrib/void/browser/react/README.md

@@ -0,0 +1,10 @@
+
+Run `node build.js` to compile the React into `out/`.
+
+A couple things to remember:
+
+- Make sure to add .js at the end of any external imports used in here, e.g. ../../../../../my_file.js. If you don't do this, you will get untraceable errors.
+
+- src/ needs to be shallow (1 folder deep) so the detection of externals works properly (see tsup.config.js).
+
+

src/vs/workbench/contrib/void/browser/react/build.js

@@ -0,0 +1,13 @@
+import { execSync } from 'child_process';
+
+// clear temp dirs
+execSync('npx rimraf out/ && npx rimraf src2/')
+
+// build and scope tailwind: https://www.npmjs.com/package/scope-tailwind
+execSync('npx scope-tailwind ./src -o src2/ -s void-scope -c styles.css -p "prefix-" ')
+
+// tsup to build src2/ into out/
+execSync('npx tsup')
+
+
+console.log('✅ Done building! Kill your build script(s) (Ctrl+D in them), then press Cmd+Shift+B again.')

src/vs/workbench/contrib/void/browser/react/src/markdown/BlockCode.tsx

@@ -0,0 +1,41 @@
+import React, { ReactNode } from "react"
+import SyntaxHighlighter from "react-syntax-highlighter";
+import { atomOneDarkReasonable } from "react-syntax-highlighter/dist/esm/styles/hljs";
+
+
+export const BlockCode = ({ text, buttonsOnHover, language }: { text: string, buttonsOnHover?: ReactNode, language?: string }) => {
+
+	const customStyle = {
+		...atomOneDarkReasonable,
+		'code[class*="language-"]': {
+			...atomOneDarkReasonable['code[class*="language-"]'],
+			background: "none",
+		},
+	}
+
+	return (<>
+		<div className={`relative group w-full bg-vscode-sidebar-bg overflow-hidden isolate`}>
+
+			{buttonsOnHover === null ? null : (
+				<div className="absolute top-0 right-0 opacity-0 group-hover:opacity-100 duration-200">
+					<div className="flex space-x-2 p-2">{buttonsOnHover}</div>
+				</div>
+			)}
+
+			<div
+				className={`overflow-x-auto rounded-sm text-vscode-editor-fg bg-vscode-editor-bg`}
+			>
+				<SyntaxHighlighter
+					language={language ?? 'plaintext'} // TODO must auto detect language
+					style={customStyle}
+					className={"rounded-sm"}
+				>
+					{text}
+				</SyntaxHighlighter>
+
+			</div>
+		</div>
+	</>
+	)
+}
+

src/vs/workbench/contrib/void/browser/react/src/markdown/MarkdownRender.tsx

@@ -0,0 +1,222 @@
+import React, { JSX, useCallback, useEffect, useState } from 'react'
+import { marked, MarkedToken, Token } from 'marked'
+import { BlockCode } from './BlockCode.js'
+import { useService } from '../util/services.js'
+
+
+enum CopyButtonState {
+	Copy = 'Copy',
+	Copied = 'Copied!',
+	Error = 'Could not copy',
+}
+
+const COPY_FEEDBACK_TIMEOUT = 1000 // amount of time to say 'Copied!'
+
+const CodeButtonsOnHover = ({ diffRepr: text }: { diffRepr: string }) => {
+	const [copyButtonState, setCopyButtonState] = useState(CopyButtonState.Copy)
+	const inlineDiffService = useService('inlineDiffService')
+
+	const clipboardService = useService('clipboardService')
+
+
+	useEffect(() => {
+		if (copyButtonState !== CopyButtonState.Copy) {
+			setTimeout(() => {
+				setCopyButtonState(CopyButtonState.Copy)
+			}, COPY_FEEDBACK_TIMEOUT)
+		}
+	}, [copyButtonState])
+
+	const onCopy = useCallback(() => {
+		clipboardService.writeText(text)
+			.then(() => { setCopyButtonState(CopyButtonState.Copied) })
+			.catch(() => { setCopyButtonState(CopyButtonState.Error) })
+	}, [text, clipboardService])
+
+	return <>
+		<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 () => {
+
+				inlineDiffService.startStreaming('ctrl+l', text)
+			}}
+		>
+			Apply
+		</button>
+	</>
+}
+
+
+const RenderToken = ({ token, nested = false }: { token: Token | string, nested?: boolean }): JSX.Element => {
+
+	// deal with built-in tokens first (assume marked token)
+	const t = token as MarkedToken
+
+	if (t.type === "space") {
+		return <span>{t.raw}</span>
+	}
+
+	if (t.type === "code") {
+		return <BlockCode
+			text={t.text}
+			language={t.lang}
+			buttonsOnHover={<CodeButtonsOnHover diffRepr={t.text} />}
+		/>
+	}
+
+	if (t.type === "heading") {
+		const HeadingTag = `h${t.depth}` as keyof JSX.IntrinsicElements
+		return <HeadingTag>{t.text}</HeadingTag>
+	}
+
+	if (t.type === "table") {
+		return (
+			<table>
+				<thead>
+					<tr>
+						{t.header.map((cell: any, index: number) => (
+							<th key={index} style={{ textAlign: t.align[index] || "left" }}>
+								{cell.raw}
+							</th>
+						))}
+					</tr>
+				</thead>
+				<tbody>
+					{t.rows.map((row: any[], rowIndex: number) => (
+						<tr key={rowIndex}>
+							{row.map((cell: any, cellIndex: number) => (
+								<td
+									key={cellIndex}
+									style={{ textAlign: t.align[cellIndex] || "left" }}
+								>
+									{cell.raw}
+								</td>
+							))}
+						</tr>
+					))}
+				</tbody>
+			</table>
+		)
+	}
+
+	if (t.type === "hr") {
+		return <hr />
+	}
+
+	if (t.type === "blockquote") {
+		return <blockquote>{t.text}</blockquote>
+	}
+
+	if (t.type === "list") {
+		const ListTag = t.ordered ? "ol" : "ul"
+		return (
+			<ListTag
+				start={t.start ? t.start : undefined}
+				className={`list-inside ${t.ordered ? "list-decimal" : "list-disc"}`}
+			>
+				{t.items.map((item, index) => (
+					<li key={index}>
+						{item.task && (
+							<input type="checkbox" checked={item.checked} readOnly />
+						)}
+						<MarkdownRender string={item.text} nested={true} />
+					</li>
+				))}
+			</ListTag>
+		)
+	}
+
+	if (t.type === "paragraph") {
+		const contents = <>
+			{t.tokens.map((token, index) => (
+				<RenderToken key={index} token={token} />
+			))}
+		</>
+		if (nested)
+			return contents
+		return <p>{contents}</p>
+	}
+
+	// don't actually render <html> tags, just render strings of them
+	if (t.type === "html") {
+		return (
+			<pre>
+				{`<html>`}
+				{t.raw}
+				{`</html>`}
+			</pre>
+		)
+	}
+
+	if (t.type === "text" || t.type === "escape") {
+		return <span>{t.raw}</span>
+	}
+
+	if (t.type === "def") {
+		return <></> // Definitions are typically not rendered
+	}
+
+	if (t.type === "link") {
+		return (
+			<a href={t.href} title={t.title ?? undefined}>
+				{t.text}
+			</a>
+		)
+	}
+
+	if (t.type === "image") {
+		return <img src={t.href} alt={t.text} title={t.title ?? undefined} />
+	}
+
+	if (t.type === "strong") {
+		return <strong>{t.text}</strong>
+	}
+
+	if (t.type === "em") {
+		return <em>{t.text}</em>
+	}
+
+	// inline code
+	if (t.type === "codespan") {
+		return (
+			<code className="text-vscode-editor-fg bg-vscode-editor-bg px-1 rounded-sm font-mono">
+				{t.text}
+			</code>
+		)
+	}
+
+	if (t.type === "br") {
+		return <br />
+	}
+
+	// strikethrough
+	if (t.type === "del") {
+		return <del>{t.text}</del>
+	}
+
+	// default
+	return (
+		<div className="bg-orange-50 rounded-sm overflow-hidden">
+			<span className="text-xs text-orange-500">Unknown type:</span>
+			{t.raw}
+		</div>
+	)
+}
+
+export const MarkdownRender = ({ string, nested = false }: { string: string, nested?: boolean }) => {
+	const tokens = marked.lexer(string); // https://marked.js.org/using_pro#renderer
+	return (
+		<>
+			{tokens.map((token, index) => (
+				<RenderToken key={index} token={token} nested={nested} />
+			))}
+		</>
+	)
+}
+

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/ErrorDisplay.tsx

@@ -0,0 +1,159 @@
+import React, { useState } from 'react';
+import { AlertCircle, ChevronDown, ChevronUp, X } from 'lucide-react';
+
+
+// const opaqueMessage = `\
+// Unfortunately, Void can't see the full error. However, you should be able to find more details by pressing ${getCmdKey()}+Shift+P, typing "Toggle Developer Tools", and looking at the console.\n
+// This error often means you have an incorrect API key. If you're self-hosting your own server, it might mean your CORS headers are off, and you should make sure your server's response has the header "Access-Control-Allow-Origins" set to "*", or at least allows "vscode-file://vscode-app".`
+// if ((error instanceof Error) && (error.cause + '').includes('TypeError: Failed to fetch')) {
+// 	e = error as any
+// 	e['Void Team'] = opaqueMessage
+// }
+
+
+type Details = {
+	message: string,
+	name: string,
+	stack: string | null,
+	cause: string | null,
+	code: string | null,
+	additional: Record<string, any>
+}
+
+// Get detailed error information
+const getErrorDetails = (error: unknown) => {
+
+	let details: Details;
+
+	let e: Error & { [other: string]: undefined | any }
+
+	// If fetch() fails, it gives an opaque message. We add extra details to the error.
+	if (error instanceof Error) {
+		e = error
+	}
+	// sometimes error is an object but not an Error
+	else if (typeof error === 'object') {
+		e = new Error(`More details below.`, { cause: JSON.stringify(error) })
+
+	}
+	else {
+		e = new Error(String(error))
+	}
+	// console.log('error display', JSON.stringify(e))
+
+	const message = e.message && e.error ?
+		(e.message + ':\n' + e.error)
+		: e.message || e.error || JSON.stringify(error)
+
+	details = {
+		name: e.name || 'Error',
+		message: message,
+		stack: null, //  e.stack is ignored because it's ugly and not very useful
+		cause: e.cause ? String(e.cause) : null,
+		code: e.code || null,
+		additional: {}
+	}
+
+
+	// Collect any additional properties from the e
+	for (let prop of Object.getOwnPropertyNames(e).filter((prop) => !Object.keys(details).includes(prop)))
+		details.additional[prop] = (e as any)[prop]
+
+	return details;
+};
+
+
+
+export const ErrorDisplay = ({
+	error,
+	onDismiss = null,
+	showDismiss = true,
+}: {
+	error: Error | object | string,
+	onDismiss: (() => void) | null,
+	showDismiss?: boolean,
+	className?: string
+}) => {
+	const [isExpanded, setIsExpanded] = useState(false);
+
+	const details = getErrorDetails(error);
+	const hasDetails = details.cause || Object.keys(details.additional).length > 0;
+
+	return (
+		<div className={`rounded-lg border border-red-200 bg-red-50 p-4 overflow-auto`}>
+			{/* Header */}
+			<div className="flex items-start justify-between">
+				<div className="flex gap-3">
+					<AlertCircle className="h-5 w-5 text-red-500 mt-0.5" />
+					<div className="flex-1">
+						<h3 className="font-semibold text-red-800">
+							{details.name}
+						</h3>
+						<p className="text-red-700 mt-1">
+							{details.message}
+						</p>
+					</div>
+				</div>
+
+				<div className="flex gap-2">
+					{hasDetails && (
+						<button
+							onClick={() => setIsExpanded(!isExpanded)}
+							className="text-red-600 hover:text-red-800 p-1 rounded"
+						>
+							{isExpanded ? (
+								<ChevronUp className="h-5 w-5" />
+							) : (
+								<ChevronDown className="h-5 w-5" />
+							)}
+						</button>
+					)}
+					{showDismiss && onDismiss && (
+						<button
+							onClick={onDismiss}
+							className="text-red-600 hover:text-red-800 p-1 rounded"
+						>
+							<X className="h-5 w-5" />
+						</button>
+					)}
+				</div>
+			</div>
+
+			{/* Expandable Details */}
+			{isExpanded && hasDetails && (
+				<div className="mt-4 space-y-3 border-t border-red-200 pt-3">
+					{details.code && (
+						<div>
+							<span className="font-semibold text-red-800">Error Code: </span>
+							<span className="text-red-700">{details.code}</span>
+						</div>
+					)}
+
+					{details.cause && (
+						<div>
+							<span className="font-semibold text-red-800">Cause: </span>
+							<span className="text-red-700">{details.cause}</span>
+						</div>
+					)}
+
+					{Object.keys(details.additional).length > 0 && (
+						<div>
+							<span className="font-semibold text-red-800">Additional Information:</span>
+							<pre className="mt-1 text-sm text-red-700 overflow-x-auto whitespace-pre-wrap">
+								{Object.keys(details.additional).map(key => `${key}:\n${details.additional[key]}`).join('\n')}
+							</pre>
+						</div>
+					)}
+					{/* {details.stack && (
+						<div>
+							<span className="font-semibold text-red-800">Stack Trace:</span>
+							<pre className="mt-1 text-sm text-red-700 overflow-x-auto whitespace-pre-wrap">
+								{details.stack}
+							</pre>
+						</div>
+					)} */}
+				</div>
+			)}
+		</div>
+	);
+};

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/Sidebar.tsx

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+import React, { useEffect, useState } from 'react'
+import { mountFnGenerator } from '../util/mountFnGenerator.js'
+
+import { SidebarSettings } from './SidebarSettings.js';
+import { useSidebarState } from '../util/services.js';
+// import { SidebarThreadSelector } from './SidebarThreadSelector.js';
+// import { SidebarChat } from './SidebarChat.js';
+
+import '../styles.css'
+import { SidebarThreadSelector } from './SidebarThreadSelector.js';
+import { SidebarChat } from './SidebarChat.js';
+
+const Sidebar = () => {
+	const sidebarState = useSidebarState()
+	const { isHistoryOpen, currentTab: tab } = sidebarState
+
+	// className='@@void-scope'
+	return <div className='@@void-scope'>
+		<div className={`flex flex-col w-full px-2 py-2`}>
+
+			{/* <span onClick={() => {
+				const tabs = ['chat', 'settings', 'threadSelector']
+				const index = tabs.indexOf(tab)
+				sidebarStateService.setState({ currentTab: tabs[(index + 1) % tabs.length] as any })
+			}}>clickme {tab}</span> */}
+
+			<div className={`mb-2 ${isHistoryOpen ? '' : 'hidden'}`}>
+				<SidebarThreadSelector />
+			</div>
+
+			<div className={`${tab === 'chat' ? '' : 'hidden'}`}>
+				<SidebarChat />
+			</div>
+
+			<div className={`${tab === 'settings' ? '' : 'hidden'}`}>
+				<SidebarSettings />
+			</div>
+
+		</div>
+	</div>
+
+
+}
+
+
+const mountFn = mountFnGenerator(Sidebar)
+export default mountFn
+

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/SidebarChat.tsx

@@ -0,0 +1,349 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+import React, { FormEvent, Fragment, useCallback, useEffect, useRef, useState } from 'react';
+
+
+import { useConfigState, useService, useThreadsState } from '../util/services.js';
+import { generateDiffInstructions } from '../../../prompt/systemPrompts.js';
+import { userInstructionsStr } from '../../../prompt/stringifyFiles.js';
+import { ChatMessage, CodeSelection, CodeStagingSelection } from '../../../registerThreads.js';
+
+import { BlockCode } from '../markdown/BlockCode.js';
+import { MarkdownRender } from '../markdown/MarkdownRender.js';
+import { IModelService } from '../../../../../../../editor/common/services/model.js';
+import { URI } from '../../../../../../../base/common/uri.js';
+import { EndOfLinePreference } from '../../../../../../../editor/common/model.js';
+import { IDisposable } from '../../../../../../../base/common/lifecycle.js';
+import { ErrorDisplay } from './ErrorDisplay.js';
+import { LLMMessageServiceParams } from '../../../../../../../platform/void/common/llmMessageTypes.js';
+import { getCmdKey } from '../../../getCmdKey.js'
+import { HistoryInputBox } from '../../../../../../../base/browser/ui/inputbox/inputBox.js';
+import { VoidInputBox } from './inputs.js';
+
+// read files from VSCode
+const VSReadFile = async (modelService: IModelService, uri: URI): Promise<string | null> => {
+	const model = modelService.getModel(uri)
+	if (!model) return null
+	return model.getValue(EndOfLinePreference.LF)
+}
+
+
+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 = (
+	{ type, selections, setStaging }:
+		| { type: 'past', selections: CodeSelection[] | null; setStaging?: undefined }
+		| { type: 'staging', selections: CodeStagingSelection[] | null; setStaging: ((files: CodeStagingSelection[]) => void) }
+) => {
+	return (
+		!!selections && selections.length !== 0 && (
+			<div className='flex flex-wrap -mx-1 -mb-1'>
+				{selections.map((selection, i) => (
+					<Fragment key={i}>
+
+						<button
+							disabled={!setStaging}
+							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={() => {
+								if (type !== 'staging') return
+								setStaging([...selections.slice(0, i), ...selections.slice(i + 1, Infinity)])
+							}}
+						>
+							<span>{getBasename(selection.fileURI.fsPath)}</span>
+
+							{/* X button */}
+							{type === 'staging' && <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>
+						{/* selection text */}
+						{type === 'staging' && selection.selectionStr && <BlockCode text={selection.selectionStr}
+							buttonsOnHover={(<button
+								onClick={() => {
+									setStaging([...selections.slice(0, i), { ...selection, selectionStr: null }, ...selections.slice(i + 1, Infinity)])
+								}}
+								className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
+							>Remove</button>
+							)} />}
+					</Fragment>
+				))}
+			</div>
+		)
+	)
+}
+
+
+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 type='past' selections={chatMessage.selections} />
+			{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 = () => {
+
+	const chatInputRef = useRef<HTMLTextAreaElement | null>(null)
+
+	const modelService = useService('modelService')
+
+	// ----- HIGHER STATE -----
+	// sidebar state
+	const sidebarStateService = useService('sidebarStateService')
+	useEffect(() => {
+		const disposables: IDisposable[] = []
+		disposables.push(
+			sidebarStateService.onDidFocusChat(() => { chatInputRef.current?.focus() }),
+			sidebarStateService.onDidBlurChat(() => { chatInputRef.current?.blur() })
+		)
+		return () => disposables.forEach(d => d.dispose())
+	}, [sidebarStateService, chatInputRef])
+
+	// config state
+	const configState = useConfigState()
+	const { voidConfig } = configState
+
+	// threads state
+	const threadsState = useThreadsState()
+	const threadsStateService = useService('threadsStateService')
+
+	// ----- SIDEBAR CHAT state (local) -----
+
+	// state of chat
+	const [messageStream, setMessageStream] = useState<string | null>(null)
+	const [isLoading, setIsLoading] = useState(false)
+	const latestRequestIdRef = useRef<string | null>(null)
+
+	const [latestError, setLatestError] = useState<Error | string | null>(null)
+
+	const sendLLMMessageService = useService('sendLLMMessageService')
+
+
+	// state of current message
+	const [instructions, setInstructions] = useState('') // the user's instructions
+	const onChangeText = useCallback((newStr: string) => { setInstructions(newStr) }, [setInstructions])
+	const isDisabled = !instructions
+	const formRef = useRef<HTMLFormElement | null>(null)
+	const inputBoxRef: React.MutableRefObject<HistoryInputBox | null> = useRef(null);
+
+	const onSubmit = async (e: FormEvent<HTMLFormElement>) => {
+
+		e.preventDefault()
+		if (isDisabled) return
+		if (isLoading) return
+
+
+		const currSelns = threadsStateService.state._currentStagingSelections
+		const selections = !currSelns ? null : await Promise.all(
+			currSelns.map(async (sel) => ({ ...sel, content: await VSReadFile(modelService, sel.fileURI) }))
+		).then(
+			(files) => files.filter(file => file.content !== null) as CodeSelection[]
+		)
+
+		// add system message to chat history
+		const systemPromptElt: ChatMessage = { role: 'system', content: generateDiffInstructions }
+		threadsStateService.addMessageToCurrentThread(systemPromptElt)
+
+		const userContent = userInstructionsStr(instructions, selections)
+		const userHistoryElt: ChatMessage = { role: 'user', content: userContent, displayContent: instructions, selections }
+		threadsStateService.addMessageToCurrentThread(userHistoryElt)
+
+		const currentThread = threadsStateService.getCurrentThread(threadsStateService.state) // the the instant state right now, don't wait for the React state
+
+
+		// send message to LLM
+
+		const object: LLMMessageServiceParams = {
+			logging: { loggingName: 'Chat' },
+			messages: [...(currentThread?.messages ?? []).map(m => ({ role: m.role, content: m.content || '(null)' })),],
+			onText: ({ newText, fullText }) => setMessageStream(fullText),
+			onFinalMessage: ({ fullText: content }) => {
+				console.log('chat: running final message')
+
+				// add assistant's message to chat history, and clear selection
+				const assistantHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content || null }
+				threadsStateService.addMessageToCurrentThread(assistantHistoryElt)
+				setMessageStream(null)
+				setIsLoading(false)
+			},
+			onError: ({ error }) => {
+				console.log('chat: running error', error)
+
+				// add assistant's message to chat history, and clear selection
+				let content = messageStream ?? ''; // just use the current content
+				const assistantHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content || null, }
+				threadsStateService.addMessageToCurrentThread(assistantHistoryElt)
+
+				setMessageStream('')
+				setIsLoading(false)
+
+				setLatestError(error)
+			},
+			voidConfig,
+		}
+
+		const latestRequestId = sendLLMMessageService.sendLLMMessage(object)
+		latestRequestIdRef.current = latestRequestId
+
+
+		setIsLoading(true)
+		if (inputBoxRef.current) {
+			inputBoxRef.current.value = ''; // this triggers onDidChangeText
+			inputBoxRef.current.blur();
+		}
+		threadsStateService.setStaging([]) // clear staging
+		setLatestError(null)
+
+	}
+
+	const onAbort = () => {
+		// abort the LLM
+		if (latestRequestIdRef.current)
+			sendLLMMessageService.abort(latestRequestIdRef.current)
+
+		// if messageStream was not empty, add it to the history
+		const llmContent = messageStream ?? ''
+		const assistantHistoryElt: ChatMessage = { role: 'assistant', content: llmContent, displayContent: messageStream || null, }
+		threadsStateService.addMessageToCurrentThread(assistantHistoryElt)
+
+		setMessageStream('')
+		setIsLoading(false)
+
+	}
+
+
+	const currentThread = threadsStateService.getCurrentThread(threadsState)
+
+	const selections = threadsState._currentStagingSelections
+
+	return <>
+		<div className="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 || null }} />
+		</div>
+		{/* chatbar */}
+		<div className="shrink-0 py-4">
+			{/* selection */}
+			<div className="text-left">
+				<div className="relative">
+					<div className="input">
+						{/* selections */}
+						{(selections && selections.length !== 0) && <div className="p-2 pb-0 space-y-2">
+							<SelectedFiles type='staging' selections={selections} setStaging={threadsStateService.setStaging.bind(threadsStateService)} />
+						</div>}
+
+						{/* error message */}
+						{latestError === null ? null :
+							<ErrorDisplay
+								error={latestError}
+								onDismiss={() => { setLatestError(null) }}
+							/>}
+
+						<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!')
+								onSubmit(e)
+							}}>
+
+							{/* input */}
+							<VoidInputBox
+								placeholder={`${getCmdKey()}+L to select`}
+								onChangeText={onChangeText}
+								inputBoxRef={inputBoxRef}
+								multiline={true}
+								initVal=''
+							/>
+
+							{/* <textarea
+								ref={chatInputRef}
+								placeholder={`Press ${getCmdKey()}+L to select.`}
+								onChange={(e) => { setInstructions(e.target.value) }}
+								className={`w-full p-2 leading-tight resize-none max-h-[50vh] overflow-auto bg-transparent border-none !outline-none`}
+								rows={1}
+								onInput={e => { e.currentTarget.style.height = 'auto'; e.currentTarget.style.height = e.currentTarget.scrollHeight + 'px' }} // Adjust height dynamically
+							/> */}
+
+							{isLoading ?
+								// stop button
+								<button
+									onClick={onAbort}
+									type='button'
+									className="font-bold size-8 flex justify-center items-center rounded-full p-2 max-h-10"
+								>
+									<svg
+										className='scale-50'
+										stroke="currentColor" fill="currentColor" strokeWidth="0" viewBox="0 0 24 24" height="24" width="24" xmlns="http://www.w3.org/2000/svg">
+										<path d="M24 24H0V0h24v24z"></path>
+									</svg>
+								</button>
+								:
+								// submit button (up arrow)
+								<button
+									className="font-bold size-8 flex justify-center items-center rounded-full p-2 max-h-10"
+									disabled={isDisabled}
+									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>
+		</div>
+	</>
+}
+
+

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/SidebarSettings.tsx

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useConfigState, useService } from '../util/services.js';
+
+import { HistoryInputBox } from '../../../../../../../base/browser/ui/inputbox/inputBox.js';
+import { SelectBox } from '../../../../../../../base/browser/ui/selectBox/selectBox.js';
+import { ConfigState, IVoidConfigStateService } from '../../../registerConfig.js';
+import { nonDefaultConfigFields, VoidConfigField } from '../../../../../../../platform/void/common/configTypes.js';
+
+
+const SettingOfFieldAndParam = ({ field, param, configState, configStateService }:
+	{ field: VoidConfigField; param: string; configState: ConfigState; configStateService: IVoidConfigStateService }) => {
+
+	const { partialVoidConfig } = configState
+
+
+	const { enumArr, defaultVal, description } = configStateService.voidConfigInfo[field][param]
+	const val = partialVoidConfig[field]?.[param] ?? defaultVal // current value of this item
+	const initValRef = useRef(val)
+
+	const updateState = useCallback((newValue: string) => {
+		configStateService.setField(field, param, newValue)
+	}, [configStateService, field, param])
+
+
+	const inputBoxRef = useRef<HistoryInputBox | null>(null);
+	const selectBoxRef = useRef<SelectBox | null>(null);
+	const forceState = useCallback((newValue: string) => {
+		if (inputBoxRef.current) {
+			inputBoxRef.current.value = newValue;
+		}
+		if (selectBoxRef.current) {
+			selectBoxRef.current.select(enumArr?.indexOf(newValue) ?? 0);
+		}
+		// updateState is called automatically when the change happens
+	}, [enumArr, updateState])
+
+
+	const resetButton = <button
+		disabled={val === defaultVal}
+		title={val === defaultVal ? 'This is the default value.' : `Revert value to '${defaultVal}'?`}
+		className='group btn btn-sm disabled:opacity-75 disabled:cursor-default'
+		onClick={() => forceState(defaultVal)}
+	>
+		<svg
+			className='size-5 group-disabled:stroke-current group-disabled:fill-current group-hover:stroke-red-600 group-hover:fill-red-600 duration-200'
+			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
+		// (<VoidInputBox
+		// 	onChangeText={updateState}
+		// 	initVal={initValRef.current}
+		// 	multiline={false}
+		// 	placeholder=''
+		// 	inputBoxRef={inputBoxRef}
+		// />)
+		<input
+			className='input p-1 w-full'
+			type='text'
+			value={val}
+			onChange={(e) => updateState(e.target.value)}
+		/>
+		:
+		// enum
+		// (<VoidSelectBox
+		// 	onChangeSelection={updateState}
+		// 	initVal={initValRef.current}
+		// 	options={enumArr}
+		// 	selectBoxRef={selectBoxRef}
+		// />)
+		(<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 configState = useConfigState()
+	const configStateService = useService('configStateService')
+
+	const { voidConfig } = configState
+	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
+					configState={configState}
+					configStateService={configStateService}
+					field='default'
+					param='whichApi'
+				/>
+				<SettingOfFieldAndParam
+					configState={configState}
+					configStateService={configStateService}
+					field='default'
+					param='maxTokens'
+				/>
+			</div>
+
+			<hr />
+
+			{/* render all fields, but hide the ones not visible for fast tab switching */}
+			{nonDefaultConfigFields.map(field => {
+				return <div
+					key={field}
+					className={`flex flex-col gap-y-2 ${field !== current_field ? 'hidden' : ''}`}
+				>
+					{Object.keys(configStateService.voidConfigInfo[field]).map((param) => (
+						<SettingOfFieldAndParam
+							key={param}
+							configState={configState}
+							configStateService={configStateService}
+							field={field}
+							param={param}
+						/>
+					))}
+				</div>
+			})}
+		</div>
+	)
+}
+

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/SidebarThreadSelector.tsx

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+import React from "react";
+import { useService, useThreadsState } from '../util/services.js';
+
+
+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 = () => {
+	const threadsState = useThreadsState()
+	const threadsStateService = useService('threadsStateService')
+	const sidebarStateService = useService('sidebarStateService')
+
+	const { allThreads } = threadsState
+
+	// sorted by most recent to least recent
+	const sortedThreadIds = Object.keys(allThreads ?? {}).sort((threadId1, threadId2) => allThreads![threadId1].lastModified > allThreads![threadId2].lastModified ? -1 : 1)
+
+	return (
+		<div className="flex flex-col gap-y-1 overflow-y-auto h-[30vh]">
+
+			{/* X button at top right */}
+			<div className="text-right">
+				<button className="btn btn-sm" onClick={() => sidebarStateService.setState({ isHistoryOpen: false })}>
+					<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: string[] = []
+
+					const firstMsgIdx = allThreads[threadId].messages.findIndex(msg => msg.role !== 'system' && !!msg.displayContent) ?? ''
+					if (firstMsgIdx !== -1)
+						btnStringArr.push(truncate(allThreads[threadId].messages[firstMsgIdx].displayContent ?? ''))
+					else
+						btnStringArr.push('""')
+
+					const secondMsgIdx = allThreads[threadId].messages.findIndex((msg, i) => msg.role !== 'system' && !!msg.displayContent && i > firstMsgIdx) ?? ''
+					if (secondMsgIdx !== -1)
+						btnStringArr.push(truncate(allThreads[threadId].messages[secondMsgIdx].displayContent ?? ''))
+
+					const numMessagesRemaining = allThreads[threadId].messages.filter((msg, i) => msg.role !== 'system' && !!msg.displayContent && i > secondMsgIdx).length
+					if (numMessagesRemaining > 0)
+						btnStringArr.push(numMessagesRemaining + '')
+
+					const btnString = btnStringArr.join(' / ')
+
+					return (
+						<button
+							key={pastThread.id}
+							className={`rounded-sm`}
+							onClick={() => threadsStateService.switchToThread(pastThread.id)}
+							title={new Date(pastThread.createdAt).toLocaleString()}
+						>
+							{btnString}
+						</button>
+					)
+				})}
+			</div>
+
+		</div>
+	)
+}

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/inputs.tsx

@@ -0,0 +1,104 @@
+import React, { useEffect, useRef } from 'react';
+import { useService } from '../util/services.js';
+import { HistoryInputBox, InputBox } from '../../../../../../../base/browser/ui/inputbox/inputBox.js';
+import { defaultInputBoxStyles } from '../../../../../../../platform/theme/browser/defaultStyles.js';
+import { SelectBox, unthemedSelectBoxStyles } from '../../../../../../../base/browser/ui/selectBox/selectBox.js';
+
+export const VoidInputBox = ({ onChangeText, initVal, placeholder, inputBoxRef, multiline }: {
+	onChangeText: (value: string) => void;
+	placeholder: string;
+	inputBoxRef: React.MutableRefObject<InputBox | null>;
+	multiline: boolean;
+	initVal: string;
+}) => {
+	const contextViewProvider = useService('contextViewService');
+
+	const containerRef = useRef<HTMLDivElement>(null);
+
+	useEffect(() => {
+		if (!containerRef.current) return;
+
+		// create and mount the HistoryInputBox
+		inputBoxRef.current = new InputBox(
+			containerRef.current,
+			contextViewProvider,
+			{
+				inputBoxStyles: {
+					...defaultInputBoxStyles,
+					inputBackground: 'transparent',
+				},
+				placeholder,
+				flexibleHeight: multiline,
+				flexibleMaxHeight: 500,
+				flexibleWidth: false,
+
+			}
+		);
+		inputBoxRef.current.value = initVal;
+
+
+		inputBoxRef.current.onDidChange((newStr) => {
+			console.log('CHANGE TEXT on inputbox', newStr)
+			onChangeText(newStr)
+		})
+
+		// cleanup
+		return () => {
+			if (inputBoxRef.current) {
+				inputBoxRef.current.dispose();
+				if (containerRef.current) {
+					while (containerRef.current.firstChild) {
+						containerRef.current.removeChild(containerRef.current.firstChild);
+					}
+				}
+				inputBoxRef.current = null;
+			}
+		};
+	}, [inputBoxRef, contextViewProvider, placeholder, multiline, initVal, onChangeText]);
+
+	return <div ref={containerRef} className="w-full" />;
+};
+
+
+
+// export const VoidSelectBox = ({ onChangeSelection, initVal, selectBoxRef, options }: {
+// 	onChangeSelection: (value: string) => void;
+// 	initVal: string;
+// 	selectBoxRef: React.MutableRefObject<SelectBox | null>;
+// 	options: readonly string[];
+
+// }) => {
+// 	const containerRef = useRef<HTMLDivElement>(null);
+// 	const contextViewProvider = useService('contextViewService');
+
+// 	useEffect(() => {
+// 		if (!containerRef.current) return;
+
+// 		const defaultIndex = options.indexOf(initVal);
+
+// 		selectBoxRef.current = new SelectBox(
+// 			options.map(opt => ({ text: opt })),
+// 			defaultIndex,
+// 			contextViewProvider,
+// 			unthemedSelectBoxStyles
+// 		);
+
+// 		selectBoxRef.current.render(containerRef.current);
+
+// 		selectBoxRef.current.onDidSelect(e => { onChangeSelection(e.selected); });
+
+// 		// cleanup
+// 		return () => {
+// 			if (selectBoxRef.current) {
+// 				selectBoxRef.current.dispose();
+// 				if (containerRef.current) {
+// 					while (containerRef.current.firstChild) {
+// 						containerRef.current.removeChild(containerRef.current.firstChild);
+// 					}
+// 				}
+// 			}
+// 		};
+// 	}, [options, initVal, onChangeSelection, contextViewProvider, selectBoxRef]);
+
+// 	return <div ref={containerRef} className="w-full" />;
+// };

src/vs/workbench/contrib/void/browser/react/src/styles.css

@@ -0,0 +1,44 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+
+/* html {
+	font-size: var(--vscode-font-size);
+}
+
+.btn {
+	@apply cursor-pointer transition-colors;
+
+	&.btn-primary {
+		@apply bg-vscode-button-bg text-vscode-button-fg;
+
+		&:not(:disabled) {
+			@apply hover:bg-vscode-button-hoverBg;
+		}
+	}
+
+	&.btn-sm {
+		@apply px-3 py-1 text-sm;
+	}
+
+	&.btn-secondary {
+		@apply bg-vscode-button-secondary-bg text-vscode-button-secondary-fg;
+
+		&:not(:disabled) {
+			@apply hover:bg-vscode-button-secondary-hoverBg;
+		}
+	}
+
+	&:disabled {
+		@apply opacity-75 cursor-not-allowed;
+	}
+}
+
+.input {
+	@apply bg-vscode-input-bg text-vscode-input-fg border-vscode-input-border focus:outline-vscode-focus-border;
+}
+
+.dropdown {
+	@apply bg-vscode-dropdown-bg text-vscode-dropdown-foreground border-vscode-dropdown-border focus:outline-vscode-focus-border;
+} */

src/vs/workbench/contrib/void/browser/react/src/util/diffLines.tsx

@@ -0,0 +1,3 @@
+import { diffLines, Change } from 'diff';
+
+export { diffLines, Change }

src/vs/workbench/contrib/void/browser/react/src/util/mountFnGenerator.tsx

@@ -0,0 +1,17 @@
+import React, { useEffect, useState } from 'react';
+import * as ReactDOM from 'react-dom/client'
+import { ReactServicesType, VoidSidebarState } from '../../../registerSidebar.js';
+import { _registerServices } from './services.js';
+
+
+export const mountFnGenerator = (Component: React.FC) => (rootElement: HTMLElement, services: ReactServicesType) => {
+	if (typeof document === 'undefined') {
+		console.error('index.tsx error: document was undefined')
+		return
+	}
+
+	_registerServices(services)
+
+	const root = ReactDOM.createRoot(rootElement)
+	root.render(<Component />);
+}

src/vs/workbench/contrib/void/browser/react/src/util/services.tsx

@@ -0,0 +1,93 @@
+import { useState, useEffect } from 'react'
+import { ConfigState } from '../../../registerConfig.js'
+import { VoidSidebarState, ReactServicesType } from '../../../registerSidebar.js'
+import { ThreadsState } from '../../../registerThreads.js'
+
+
+// normally to do this you'd use a useEffect that calls .onDidChangeState(), but useEffect mounts too late and misses initial state changes
+
+let services: ReactServicesType
+
+// even if React hasn't mounted yet, these variables are always updated to the latest state:
+let sidebarState: VoidSidebarState
+let configState: ConfigState
+let threadsState: ThreadsState
+
+// React listens by adding a setState function to these:
+const sidebarStateListeners: Set<(s: VoidSidebarState) => void> = new Set()
+const configStateListeners: Set<(s: ConfigState) => void> = new Set()
+const threadsStateListeners: Set<(s: ThreadsState) => void> = new Set()
+
+// must call this before you can use any of the hooks below
+// this should only be called ONCE! this is the only place you don't need to dispose onDidChange. If you use state.onDidChange anywhere else, make sure to dispose it!
+
+let wasCalled = false
+
+export const _registerServices = (services_: ReactServicesType) => {
+
+	if (wasCalled) console.error(`void _registerServices was called again! It should only be called once.`)
+	wasCalled = true
+
+	services = services_
+	const { sidebarStateService, configStateService, threadsStateService, } = services
+
+	sidebarState = sidebarStateService.state
+	sidebarStateService.onDidChangeState(() => {
+		sidebarState = sidebarStateService.state
+		sidebarStateListeners.forEach(l => l(sidebarState))
+	})
+
+	configState = configStateService.state
+	configStateService.onDidChangeState(() => {
+		configState = configStateService.state
+		configStateListeners.forEach(l => l(configState))
+	})
+
+	threadsState = threadsStateService.state
+	threadsStateService.onDidChangeCurrentThread(() => {
+		threadsState = threadsStateService.state
+		threadsStateListeners.forEach(l => l(threadsState))
+	})
+
+}
+
+
+// -- services --
+export const useService = <T extends keyof ReactServicesType,>(serviceName: T) => {
+	if (services === null) {
+		throw new Error('useAccessor must be used within an AccessorProvider')
+	}
+	return services[serviceName] as ReactServicesType[T]
+}
+
+// -- state of services --
+
+export const useSidebarState = () => {
+	const [s, ss] = useState(sidebarState)
+	useEffect(() => {
+		ss(sidebarState)
+		sidebarStateListeners.add(ss)
+		return () => { sidebarStateListeners.delete(ss) }
+	}, [ss])
+	return s
+}
+
+export const useConfigState = () => {
+	const [s, ss] = useState(configState)
+	useEffect(() => {
+		ss(configState)
+		configStateListeners.add(ss)
+		return () => { configStateListeners.delete(ss) }
+	}, [ss])
+	return s
+}
+
+export const useThreadsState = () => {
+	const [s, ss] = useState(threadsState)
+	useEffect(() => {
+		ss(threadsState)
+		threadsStateListeners.add(ss)
+		return () => { threadsStateListeners.delete(ss) }
+	}, [ss])
+	return s
+}

src/vs/workbench/contrib/void/browser/react/tailwind.config.js

@@ -0,0 +1,32 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+	content: ['./src2/**/*.{jsx,tsx}'], // uses these files to decide how to transform the css file
+	theme: {
+		extend: {
+			// inject user's vscode theme colors: https://code.visualstudio.com/api/extension-guides/webview#theming-webview-content
+			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: [],
+	prefix: 'prefix-'
+}
+

src/vs/workbench/contrib/void/browser/react/tsconfig.json

@@ -0,0 +1,16 @@
+{
+	"compilerOptions": {
+		"strict": true,
+		"exactOptionalPropertyTypes": false,
+
+		"jsx": "react-jsx",
+		"moduleResolution": "NodeNext",
+		"module": "NodeNext",
+		"esModuleInterop": true,
+	},
+	"include": [
+		// this is just for type checking, so src/ is the correct dir
+		"./src/**/*.ts",
+		"./src/**/*.tsx"
+	]
+}

src/vs/workbench/contrib/void/browser/react/tsup.config.js

@@ -0,0 +1,33 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+	entry: [
+		'./src2/sidebar-tsx/Sidebar.tsx',
+		'./src2/util/diffLines.tsx',
+	],
+	outDir: './out',
+	format: ['esm'],
+	splitting: false,
+
+	// dts: true,
+	// sourcemap: true,
+
+	clean: true,
+	platform: 'browser', // 'node'
+	target: 'esnext',
+	injectStyle: true, // bundle css into the output file
+	outExtension: () => ({ js: '.js' }),
+	// default behavior is to take local files and make them internal (bundle them) and take imports like 'react' and leave them external (don't bundle them), we want the opposite in many ways
+	noExternal: [ // noExternal means we should take these things and make them not external (bundle them into the output file) - anything that doesn't start with a "." needs to be force-flagged as not external
+		/^(?!\.).*$/
+	],
+	external: [ // these imports should be kept external ../../../ are external (this is just an optimization so the output file doesn't re-implement functions)
+		new RegExp('../../../*.js'
+			.replaceAll('.', '\\.')
+			.replaceAll('*', '.*'))
+	],
+	treeshake: true,
+	esbuildOptions(options) {
+		options.outbase = 'src2'  // tries copying the folder hierarchy starting at src2
+	}
+})

src/vs/workbench/contrib/void/browser/registerActions.ts

@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { KeyCode, KeyMod } from '../../../../base/common/keyCodes.js';
+
+
+import { Action2, MenuId, registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { ServicesAccessor } from '../../../../editor/browser/editorExtensions.js';
+
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { CodeStagingSelection, IThreadHistoryService } from './registerThreads.js';
+// import { IVoidConfigService } from './registerSettings.js';
+// import { IEditorService } from '../../../services/editor/common/editorService.js';
+
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { IRange } from '../../../../editor/common/core/range.js';
+import { ITextModel } from '../../../../editor/common/model.js';
+import { IVoidSidebarStateService, VOID_VIEW_ID } from './registerSidebar.js';
+// import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+
+
+// ---------- Register commands and keybindings ----------
+
+
+const roundRangeToLines = (range: IRange | null | undefined) => {
+	if (!range)
+		return null
+	// IRange is 1-indexed
+	const endLine = range.endColumn === 1 ? range.endLineNumber - 1 : range.endLineNumber // e.g. if the user triple clicks, it selects column=0, line=line -> column=0, line=line+1
+	const newRange: IRange = {
+		startLineNumber: range.startLineNumber,
+		startColumn: 1,
+		endLineNumber: endLine,
+		endColumn: Number.MAX_SAFE_INTEGER
+	}
+	return newRange
+}
+
+const getContentInRange = (model: ITextModel, range: IRange | null) => {
+	if (!range)
+		return null
+	const content = model.getValueInRange(range)
+	const trimmedContent = content
+		.replace(/^\s*\n/g, '') // trim pure whitespace lines from start
+		.replace(/\n\s*$/g, '') // trim pure whitespace lines from end
+	return trimmedContent
+}
+
+// Action: when press ctrl+L, show the sidebar chat and add to the selection
+registerAction2(class extends Action2 {
+	constructor() {
+		super({ id: 'void.ctrl+l', title: 'Show Sidebar', keybinding: { primary: KeyMod.CtrlCmd | KeyCode.KeyL, weight: KeybindingWeight.BuiltinExtension } });
+	}
+	async run(accessor: ServicesAccessor): Promise<void> {
+
+		const model = accessor.get(ICodeEditorService).getActiveCodeEditor()?.getModel()
+		if (!model)
+			return
+
+
+		const stateService = accessor.get(IVoidSidebarStateService)
+		stateService.setState({ isHistoryOpen: false, currentTab: 'chat' })
+		stateService.fireFocusChat()
+
+		// add selection
+		const threadHistoryService = accessor.get(IThreadHistoryService)
+		const currentStaging = threadHistoryService.state._currentStagingSelections
+		const currentStagingEltIdx = currentStaging?.findIndex(s => s.fileURI.fsPath === model.uri.fsPath)
+
+		// if there exists a selection with this URI, replace it
+		const selectionRange = roundRangeToLines(
+			accessor.get(IEditorService).activeTextEditorControl?.getSelection()
+		)
+
+		if (selectionRange) {
+			const selection: CodeStagingSelection = {
+				selectionStr: getContentInRange(model, selectionRange),
+				fileURI: model.uri
+			}
+
+			if (currentStagingEltIdx !== undefined && currentStagingEltIdx !== -1) {
+				threadHistoryService.setStaging([
+					...currentStaging!.slice(0, currentStagingEltIdx),
+					selection,
+					...currentStaging!.slice(currentStagingEltIdx + 1, Infinity)
+				])
+			}
+			else {
+				threadHistoryService.setStaging([...(currentStaging ?? []), selection])
+			}
+		}
+
+	}
+});
+
+
+// New chat menu button
+registerAction2(class extends Action2 {
+	constructor() {
+		super({
+			id: 'void.newChatAction',
+			title: 'View past chats',
+			icon: { id: 'add' },
+			menu: [{ id: MenuId.ViewTitle, group: 'navigation', when: ContextKeyExpr.equals('view', VOID_VIEW_ID), }]
+		});
+	}
+	async run(accessor: ServicesAccessor): Promise<void> {
+		const stateService = accessor.get(IVoidSidebarStateService)
+		stateService.setState({ isHistoryOpen: false, currentTab: 'chat' })
+		stateService.fireFocusChat()
+
+		const historyService = accessor.get(IThreadHistoryService)
+		historyService.startNewThread()
+	}
+})
+
+// History menu button
+registerAction2(class extends Action2 {
+	constructor() {
+		super({
+			id: 'void.historyAction',
+			title: 'View past chats',
+			icon: { id: 'history' },
+			menu: [{ id: MenuId.ViewTitle, group: 'navigation', when: ContextKeyExpr.equals('view', VOID_VIEW_ID), }]
+		});
+	}
+	async run(accessor: ServicesAccessor): Promise<void> {
+		const stateService = accessor.get(IVoidSidebarStateService)
+		stateService.setState({ isHistoryOpen: !stateService.state.isHistoryOpen, currentTab: 'chat' })
+		stateService.fireBlurChat()
+	}
+})
+
+// Settings (API config) menu button
+registerAction2(class extends Action2 {
+	constructor() {
+		super({
+			id: 'void.viewSettings',
+			title: 'Void settings',
+			icon: { id: 'settings-gear' },
+			menu: [{ id: MenuId.ViewTitle, group: 'navigation', when: ContextKeyExpr.equals('view', VOID_VIEW_ID), }]
+		});
+	}
+	async run(accessor: ServicesAccessor): Promise<void> {
+		const stateService = accessor.get(IVoidSidebarStateService)
+		stateService.setState({ isHistoryOpen: false, currentTab: stateService.state.currentTab === 'settings' ? 'chat' : 'settings' })
+		stateService.fireBlurChat()
+	}
+})

src/vs/workbench/contrib/void/browser/registerConfig.ts

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IEncryptionService } from '../../../../platform/encryption/common/encryptionService.js';
+import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { PartialVoidConfig, VoidConfig, nonDefaultConfigFields, voidConfigInfo, VoidConfigField, VoidConfigInfo } from '../../../../platform/void/common/configTypes.js';
+
+
+const getVoidConfig = (partialVoidConfig: PartialVoidConfig): VoidConfig => {
+	const config = {} as PartialVoidConfig
+	for (const field of [...nonDefaultConfigFields, 'default'] as const) {
+		config[field] = {}
+		for (const prop in voidConfigInfo[field]) {
+			config[field][prop] = partialVoidConfig[field]?.[prop]?.trim() || voidConfigInfo[field][prop].defaultVal
+		}
+	}
+	return config as VoidConfig
+}
+
+
+const VOID_CONFIG_KEY = 'void.partialVoidConfig'
+
+export type SetFieldFnType = <K extends VoidConfigField>(field: K, param: keyof VoidConfigInfo[K], newVal: string) => Promise<void>;
+
+export type ConfigState = {
+	partialVoidConfig: PartialVoidConfig; // free parameter
+	voidConfig: VoidConfig; // computed from partialVoidConfig
+}
+
+export interface IVoidConfigStateService {
+	readonly _serviceBrand: undefined;
+	readonly state: ConfigState;
+	readonly voidConfigInfo: VoidConfigInfo;
+	onDidChangeState: Event<void>;
+	setField: SetFieldFnType;
+}
+
+export const IVoidConfigStateService = createDecorator<IVoidConfigStateService>('VoidConfigStateService');
+class VoidConfigStateService extends Disposable implements IVoidConfigStateService {
+	_serviceBrand: undefined;
+
+	private readonly _onDidChangeState = new Emitter<void>();
+	readonly onDidChangeState: Event<void> = this._onDidChangeState.event; // this is primarily for use in react, so react can listen + update on state changes
+
+	state: ConfigState;
+	readonly voidConfigInfo: VoidConfigInfo = voidConfigInfo; // just putting this here for simplicity, it's static though
+
+	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, just treat partialVoidConfig like it's empty
+		this.state = {
+			partialVoidConfig: {},
+			voidConfig: getVoidConfig({}),
+		}
+
+		// read and update the actual state immediately
+		this._readPartialVoidConfig().then(partialVoidConfig => {
+			this._setState(partialVoidConfig)
+		})
+
+	}
+
+	private async _readPartialVoidConfig(): Promise<PartialVoidConfig> {
+		const encryptedPartialConfig = this._storageService.get(VOID_CONFIG_KEY, StorageScope.APPLICATION)
+
+		if (!encryptedPartialConfig)
+			return {}
+
+		const partialVoidConfigStr = await this._encryptionService.decrypt(encryptedPartialConfig)
+		return JSON.parse(partialVoidConfigStr)
+	}
+
+
+	private async _storePartialVoidConfig(partialVoidConfig: PartialVoidConfig) {
+		const encryptedPartialConfigStr = await this._encryptionService.encrypt(JSON.stringify(partialVoidConfig))
+		this._storageService.store(VOID_CONFIG_KEY, encryptedPartialConfigStr, StorageScope.APPLICATION, StorageTarget.USER)
+	}
+
+
+	// Set field on PartialVoidConfig
+	setField: SetFieldFnType = async <K extends VoidConfigField>(field: K, param: keyof VoidConfigInfo[K], newVal: string) => {
+		const { partialVoidConfig } = this.state
+
+		const newPartialConfig: PartialVoidConfig = {
+			...partialVoidConfig,
+			[field]: {
+				...partialVoidConfig[field],
+				[param]: newVal
+			}
+		}
+		await this._storePartialVoidConfig(newPartialConfig)
+		this._setState(newPartialConfig)
+	}
+
+	// internal function to update state, should be called every time state changes
+	private async _setState(partialVoidConfig: PartialVoidConfig) {
+		this.state = {
+			partialVoidConfig: partialVoidConfig,
+			voidConfig: getVoidConfig(partialVoidConfig),
+		}
+		this._onDidChangeState.fire()
+	}
+
+}
+
+registerSingleton(IVoidConfigStateService, VoidConfigStateService, InstantiationType.Eager);

src/vs/workbench/contrib/void/browser/registerSidebar.ts

@@ -0,0 +1,252 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import {
+	Extensions as ViewContainerExtensions, IViewContainersRegistry,
+	ViewContainerLocation, IViewsRegistry, Extensions as ViewExtensions,
+	IViewDescriptorService,
+} from '../../../common/views.js';
+
+import * as nls from '../../../../nls.js';
+
+import { Codicon } from '../../../../base/common/codicons.js';
+import { localize } from '../../../../nls.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { KeyCode, KeyMod } from '../../../../base/common/keyCodes.js';
+
+
+import { IViewPaneOptions, ViewPane } from '../../../browser/parts/views/viewPane.js';
+
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { IThreadHistoryService } from './registerThreads.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { IContextMenuService, IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.js';
+// import { IVoidConfigService } from './registerSettings.js';
+// import { IEditorService } from '../../../services/editor/common/editorService.js';
+
+import mountFn from './react/out/sidebar-tsx/Sidebar.js';
+
+import { IVoidConfigStateService } from './registerConfig.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IInlineDiffsService } from './registerInlineDiffs.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ISendLLMMessageService } from '../../../../platform/void/browser/llmMessageService.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+
+
+// import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+
+
+// compare against search.contribution.ts and https://app.greptile.com/chat/w1nsmt3lauwzculipycpn?repo=github%3Amain%3Amicrosoft%2Fvscode
+// and debug.contribution.ts, scm.contribution.ts (source control)
+
+export type VoidSidebarState = {
+	isHistoryOpen: boolean;
+	currentTab: 'chat' | 'settings';
+}
+
+export type ReactServicesType = {
+	sidebarStateService: IVoidSidebarStateService;
+	configStateService: IVoidConfigStateService;
+	threadsStateService: IThreadHistoryService;
+	fileService: IFileService;
+	modelService: IModelService;
+	inlineDiffService: IInlineDiffsService;
+	sendLLMMessageService: ISendLLMMessageService;
+	clipboardService: IClipboardService;
+
+	contextViewService: IContextViewService;
+	contextMenuService: IContextMenuService;
+}
+
+// ---------- Define viewpane ----------
+
+class VoidSidebarViewPane extends ViewPane {
+
+	constructor(
+		options: IViewPaneOptions,
+		@IInstantiationService instantiationService: IInstantiationService,
+		@IViewDescriptorService viewDescriptorService: IViewDescriptorService,
+		@IConfigurationService configurationService: IConfigurationService,
+		@IContextKeyService contextKeyService: IContextKeyService,
+		@IThemeService themeService: IThemeService,
+		@IContextMenuService contextMenuService: IContextMenuService,
+		@IKeybindingService keybindingService: IKeybindingService,
+		@IOpenerService openerService: IOpenerService,
+		@ITelemetryService telemetryService: ITelemetryService,
+		@IHoverService hoverService: IHoverService,
+		// Void:
+		// @IVoidSidebarStateService private readonly _voidSidebarStateService: IVoidSidebarStateService,
+		// @IThreadHistoryService private readonly _threadHistoryService: IThreadHistoryService,
+		// TODO chat service
+	) {
+		super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService)
+
+	}
+
+
+
+	protected override renderBody(parent: HTMLElement): void {
+		super.renderBody(parent);
+		parent.style.overflow = 'auto'
+		parent.style.userSelect = 'text'
+
+		// gets set immediately
+		this.instantiationService.invokeFunction(accessor => {
+			const services: ReactServicesType = {
+				configStateService: accessor.get(IVoidConfigStateService),
+				sidebarStateService: accessor.get(IVoidSidebarStateService),
+				threadsStateService: accessor.get(IThreadHistoryService),
+				fileService: accessor.get(IFileService),
+				modelService: accessor.get(IModelService),
+				inlineDiffService: accessor.get(IInlineDiffsService),
+				sendLLMMessageService: accessor.get(ISendLLMMessageService),
+				clipboardService: accessor.get(IClipboardService),
+				contextViewService: accessor.get(IContextViewService),
+				contextMenuService: accessor.get(IContextMenuService),
+			}
+			mountFn(parent, services);
+		});
+	}
+
+}
+
+
+
+// ---------- Register viewpane inside the void container ----------
+
+const voidThemeIcon = Codicon.symbolObject;
+const voidViewIcon = registerIcon('void-view-icon', voidThemeIcon, localize('voidViewIcon', 'View icon of the Void chat view.'));
+
+// called VIEWLET_ID in other places for some reason
+export const VOID_VIEW_CONTAINER_ID = 'workbench.view.void'
+export const VOID_VIEW_ID = VOID_VIEW_CONTAINER_ID // not sure if we can change this
+
+// Register view container
+const viewContainerRegistry = Registry.as<IViewContainersRegistry>(ViewContainerExtensions.ViewContainersRegistry);
+const viewContainer = viewContainerRegistry.registerViewContainer({
+	id: VOID_VIEW_CONTAINER_ID,
+	title: nls.localize2('void', 'Void'), // this is used to say "Void" (Ctrl + L)
+	ctorDescriptor: new SyncDescriptor(ViewPaneContainer, [VOID_VIEW_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]),
+	hideIfEmpty: false,
+	icon: voidViewIcon,
+	order: 1,
+}, ViewContainerLocation.AuxiliaryBar, { doNotRegisterOpenCommand: true, });
+
+
+
+// Register search default location to the container (sidebar)
+const viewsRegistry = Registry.as<IViewsRegistry>(ViewExtensions.ViewsRegistry);
+viewsRegistry.registerViews([{
+	id: VOID_VIEW_ID,
+	hideByDefault: false, // start open
+	containerIcon: voidViewIcon,
+	name: nls.localize2('void chat', "Chat"), // this says ... : CHAT
+	ctorDescriptor: new SyncDescriptor(VoidSidebarViewPane),
+	canToggleVisibility: false,
+	canMoveView: true,
+	openCommandActionDescriptor: {
+		id: viewContainer.id,
+		keybindings: {
+			primary: KeyMod.CtrlCmd | KeyCode.KeyL,
+		},
+		order: 1
+	},
+}], viewContainer);
+
+
+
+// ---------- Register service that manages sidebar's state ----------
+
+export interface IVoidSidebarStateService {
+	readonly _serviceBrand: undefined;
+
+	readonly state: VoidSidebarState; // readonly to the user
+	setState(newState: Partial<VoidSidebarState>): void;
+	onDidChangeState: Event<void>;
+
+	onDidFocusChat: Event<void>;
+	onDidBlurChat: Event<void>;
+	fireFocusChat(): void;
+	fireBlurChat(): void;
+
+	openView(): void;
+}
+
+
+export const IVoidSidebarStateService = createDecorator<IVoidSidebarStateService>('voidSidebarStateService');
+class VoidSidebarStateService extends Disposable implements IVoidSidebarStateService {
+	_serviceBrand: undefined;
+
+	private readonly _onDidChangeState = new Emitter<void>();
+	readonly onDidChangeState: Event<void> = this._onDidChangeState.event;
+
+	private readonly _onFocusChat = new Emitter<void>();
+	readonly onDidFocusChat: Event<void> = this._onFocusChat.event;
+
+	private readonly _onBlurChat = new Emitter<void>();
+	readonly onDidBlurChat: Event<void> = this._onBlurChat.event;
+
+
+	// state
+	state: VoidSidebarState
+
+
+	setState(newState: Partial<VoidSidebarState>) {
+		// make sure view is open if the tab changes
+		if ('currentTab' in newState) {
+			this.openView()
+		}
+
+		this.state = { ...this.state, ...newState }
+		this._onDidChangeState.fire()
+	}
+
+	fireFocusChat() {
+		this._onFocusChat.fire()
+	}
+
+	fireBlurChat() {
+		this._onBlurChat.fire()
+	}
+
+	openView() {
+		this._viewsService.openViewContainer(VOID_VIEW_CONTAINER_ID);
+		this._viewsService.openView(VOID_VIEW_ID);
+	}
+
+	constructor(
+		@IViewsService private readonly _viewsService: IViewsService,
+		// @IThreadHistoryService private readonly _threadHistoryService: IThreadHistoryService,
+	) {
+		super()
+		// auto open the view on mount (if it bothers you this is here, this is technically just initializing the state of the view)
+		this.openView()
+
+		// initial state
+		this.state = {
+			isHistoryOpen: false,
+			currentTab: 'chat',
+		}
+
+	}
+
+}
+
+registerSingleton(IVoidSidebarStateService, VoidSidebarStateService, InstantiationType.Eager);

src/vs/workbench/contrib/void/browser/registerThreads.ts

@@ -0,0 +1,201 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
+
+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 { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+
+import { URI } from '../../../../base/common/uri.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+
+// if selectionStr is null, it means just send the whole file
+export type CodeSelection = {
+	selectionStr: string | null;
+	fileURI: URI;
+	content: string;
+}
+
+export type CodeStagingSelection = {
+	selectionStr: string | null;
+	fileURI: URI;
+}
+
+
+// WARNING: changing this format is a big deal!!!!!! need to migrate old format to new format on users' computers so people don't get errors.
+export type ChatMessage =
+	| {
+		role: 'user';
+		content: string | null; // content sent to the llm - yes, allowed to be '', will be replaced with (empty)
+		displayContent: string | null; // content displayed to user  - yes, allowed to be '', will be ignored
+		selections: CodeSelection[] | null; // the user's selection
+	}
+	| {
+		role: 'assistant';
+		content: string | null; // content received from LLM  - yes, allowed to be '', will be replaced with (empty)
+		displayContent: string | null; // content displayed to user (this is the same as content for now) - yes, allowed to be '', will be ignored
+	}
+	| {
+		role: 'system';
+		content: string;
+		displayContent?: undefined;
+	}
+
+// a 'thread' means a chat message history
+export type ChatThreads = {
+	[id: string]: {
+		id: string; // store the id here too
+		createdAt: string; // ISO string
+		lastModified: string; // ISO string
+		messages: ChatMessage[];
+	};
+}
+
+export type ThreadsState = {
+	allThreads: ChatThreads;
+	_currentThreadId: string | null; // intended for internal use only
+	_currentStagingSelections: CodeStagingSelection[] | null;
+}
+
+
+const newThreadObject = () => {
+	const now = new Date().toISOString()
+	return {
+		id: new Date().getTime().toString(),
+		createdAt: now,
+		lastModified: now,
+		messages: [],
+	}
+}
+
+const THREAD_STORAGE_KEY = 'void.threadsHistory'
+
+export interface IThreadHistoryService {
+	readonly _serviceBrand: undefined;
+
+	readonly state: ThreadsState;
+	onDidChangeCurrentThread: Event<void>;
+
+	getCurrentThread(state: ThreadsState): ChatThreads[string] | null;
+	startNewThread(): void;
+	switchToThread(threadId: string): void;
+	addMessageToCurrentThread(message: ChatMessage): void;
+
+	setStaging(stagingSelection: CodeStagingSelection[] | null): void;
+
+}
+
+export const IThreadHistoryService = createDecorator<IThreadHistoryService>('voidThreadHistoryService');
+class ThreadHistoryService extends Disposable implements IThreadHistoryService {
+	_serviceBrand: undefined;
+
+	// this fires when the current thread changes at all (a switch of currentThread, or a message added to it, etc)
+	private readonly _onDidChangeCurrentThread = new Emitter<void>();
+	readonly onDidChangeCurrentThread: Event<void> = this._onDidChangeCurrentThread.event;
+
+	state: ThreadsState // allThreads is persisted, currentThread is not
+
+	constructor(
+		@IStorageService private readonly _storageService: IStorageService,
+	) {
+		super()
+
+		this.state = {
+			allThreads: this._readAllThreads(),
+			_currentThreadId: null,
+			_currentStagingSelections: null,
+		}
+	}
+
+
+	private _readAllThreads(): ChatThreads {
+		const threads = this._storageService.get(THREAD_STORAGE_KEY, StorageScope.APPLICATION)
+		return threads ? JSON.parse(threads) : {}
+	}
+
+	private _storeAllThreads(threads: ChatThreads) {
+		this._storageService.store(THREAD_STORAGE_KEY, JSON.stringify(threads), StorageScope.APPLICATION, StorageTarget.USER)
+	}
+
+	// this should be the only place this.state = ... appears besides constructor
+	private _setState(state: Partial<ThreadsState>, affectsCurrent: boolean) {
+		this.state = {
+			...this.state,
+			...state
+		}
+		if (affectsCurrent)
+			this._onDidChangeCurrentThread.fire()
+	}
+
+	// must "prove" that you have access to the current state by providing it
+	getCurrentThread(state: ThreadsState): ChatThreads[string] | null {
+		return state._currentThreadId ? state.allThreads[state._currentThreadId] ?? null : null;
+	}
+
+	switchToThread(threadId: string) {
+		console.log('threadId', threadId)
+		console.log('messages', this.state.allThreads[threadId].messages)
+		this._setState({ _currentThreadId: threadId }, true)
+	}
+
+
+	startNewThread() {
+		// if a thread with 0 messages already exists, switch to it
+		const { allThreads: currentThreads } = this.state
+		for (const threadId in currentThreads) {
+			if (currentThreads[threadId].messages.length === 0) {
+				this.switchToThread(threadId)
+				return
+			}
+		}
+		// otherwise, start a new thread
+		const newThread = newThreadObject()
+
+		// update state
+		const newThreads = {
+			...currentThreads,
+			[newThread.id]: newThread
+		}
+		this._storeAllThreads(newThreads)
+		this._setState({ allThreads: newThreads, _currentThreadId: newThread.id }, true)
+	}
+
+
+	addMessageToCurrentThread(message: ChatMessage) {
+		console.log('adding ', message.role, 'to chat')
+		const { allThreads, _currentThreadId } = this.state
+
+		// get the current thread, or create one
+		let currentThread: ChatThreads[string]
+		if (_currentThreadId && (_currentThreadId in allThreads)) {
+			currentThread = allThreads[_currentThreadId]
+		}
+		else {
+			currentThread = newThreadObject()
+			this.state._currentThreadId = currentThread.id
+		}
+
+		// update state and store it
+		const newThreads = {
+			...allThreads,
+			[currentThread.id]: {
+				...currentThread,
+				lastModified: new Date().toISOString(),
+				messages: [...currentThread.messages, message],
+			}
+		}
+		this._storeAllThreads(newThreads)
+		this._setState({ allThreads: newThreads }, true) // the current thread just changed (it had a message added to it)
+	}
+
+
+	setStaging(stagingSelection: CodeStagingSelection[] | null): void {
+		this._setState({ _currentStagingSelections: stagingSelection }, true) // this is a hack for now
+	}
+
+}
+
+registerSingleton(IThreadHistoryService, ThreadHistoryService, InstantiationType.Eager);
+

src/vs/workbench/contrib/void/browser/void.contribution.ts

@@ -1,72 +1,22 @@
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import {
-	Extensions as ViewContainerExtensions, IViewContainersRegistry,
-	ViewContainerLocation, IViewsRegistry, Extensions as ViewExtensions,
-	IViewDescriptor
-} from '../../../../workbench/common/views.js';
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Glass Devtools, Inc. All rights reserved.
+ *  Void Editor additions licensed under the AGPLv3 License.
+ *--------------------------------------------------------------------------------------------*/
 
-import * as nls from '../../../../nls.js';
+// register keybinds
+import './registerActions.js'
 
-import { VoidViewPane } from '../../../../workbench/contrib/void/browser/voidViewPane.js';
+// register Settings
+import './registerConfig.js' // TODO move this to platform
 
-import { Codicon } from '../../../../base/common/codicons.js';
-import { localize } from '../../../../nls.js';
-import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
-import { ViewPaneContainer } from '../../../../workbench/browser/parts/views/viewPaneContainer.js';
+// register inline diffs
+import './registerInlineDiffs.js'
 
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { KeyCode, KeyMod } from '../../../../base/common/keyCodes.js';
-
-
-const voidViewIcon = registerIcon('void-view-icon', Codicon.search, localize('voidViewIcon', 'View icon of the Void chat view.'));
-
-
-// compare against search.contribution.ts and https://app.greptile.com/chat/w1nsmt3lauwzculipycpn?repo=github%3Amain%3Amicrosoft%2Fvscode
-// and debug.contribution.ts, scm.contribution.ts (source control)
-
-const VIEW_CONTAINER_ID = 'workbench.view.void' // called VIEWLET_ID in other places for some reason
-
-// Register view container
-const viewContainerRegistry = Registry.as<IViewContainersRegistry>(ViewContainerExtensions.ViewContainersRegistry);
-const viewContainer = viewContainerRegistry.registerViewContainer({
-	id: VIEW_CONTAINER_ID,
-	title: nls.localize2('void', 'Void'), // this is used to say "Void" (Ctrl + L)
-	ctorDescriptor: new SyncDescriptor(ViewPaneContainer, [VIEW_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]),
-	hideIfEmpty: false,
-	icon: voidViewIcon,
-	order: 1,
-}, ViewContainerLocation.AuxiliaryBar, { doNotRegisterOpenCommand: true });
-
-
-
-
-
-// this is called a descriptor, but it's the actual View that gets used inside the view container
-const VIEW_ID = VIEW_CONTAINER_ID // not sure if we can change this
-const viewDescriptor: IViewDescriptor = {
-	id: VIEW_ID,
-	containerIcon: voidViewIcon,
-	name: nls.localize2('void chat', "Chat"), // this says ... : CHAT
-	ctorDescriptor: new SyncDescriptor(VoidViewPane),
-	canToggleVisibility: false,
-	canMoveView: true,
-	openCommandActionDescriptor: {
-		id: viewContainer.id,
-		keybindings: {
-			primary: KeyMod.CtrlCmd | KeyCode.KeyL, // we don't need to disable the original ctrl+L (probably because it brings panel into focus first)
-		},
-		order: 1
-		// mnemonicTitle: nls.localize({ key: 'miViewSearch', comment: ['&& denotes a mnemonic'] }, "&&Search"),
-	}
-};
-
-
-
-
-// Register search default location to the container (sidebar)
-Registry.as<IViewsRegistry>(ViewExtensions.ViewsRegistry).registerViews([viewDescriptor], viewContainer);
-
-
-// TODO can add a configuration for the user to choose config options - see search.contribution.ts
+// register Sidebar chat
+import './registerSidebar.js'
 
+// register Thread History
+import './registerThreads.js'
 
+// register css
+import './media/void.css'

src/vs/workbench/contrib/void/browser/voidViewPane.ts

@@ -1,39 +0,0 @@
-
-
-
-import { ViewPane } from '../../../../workbench/browser/parts/views/viewPane.js';
-
-// import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-// import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
-// import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
-// import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-// import { IViewPaneOptions,  } from 'vs/workbench/browser/parts/views/viewPane';
-// import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
-// import { IOpenerService } from 'vs/platform/opener/common/opener';
-// import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-// import { IThemeService } from 'vs/platform/theme/common/themeService';
-// import { IViewDescriptorService } from 'vs/workbench/common/views';
-// import { IHoverService } from 'vs/platform/hover/browser/hover';
-
-
-export class VoidViewPane extends ViewPane {
-
-	// constructor(
-	// 	options: IViewPaneOptions,
-	// 	@IInstantiationService instantiationService: IInstantiationService,
-	// 	@IViewDescriptorService viewDescriptorService: IViewDescriptorService,
-	// 	@IConfigurationService configurationService: IConfigurationService,
-	// 	@IContextKeyService contextKeyService: IContextKeyService,
-	// 	@IThemeService themeService: IThemeService,
-	// 	@IContextMenuService contextMenuService: IContextMenuService,
-	// 	@IKeybindingService keybindingService: IKeybindingService,
-	// 	@IOpenerService openerService: IOpenerService,
-	// 	@ITelemetryService telemetryService: ITelemetryService,
-	// 	@IHoverService hoverService: IHoverService,
-	// ) {
-	// 	super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
-	// }
-
-}
-
-// register a singleton service that mounts the ViewPane here

src/vs/workbench/electron-sandbox/desktop.main.ts

@@ -328,6 +328,11 @@ export class DesktopMain extends Disposable {
 		//
 		// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
+		// // Void
+		// const sendLLMMessageService = new SendLLMMessageService();
+		// serviceCollection.set(ISendLLMMessageService, sendLLMMessageService);
+
+
 
 		return { serviceCollection, logService, storageService, configurationService };
 	}

src/vs/workbench/workbench.common.main.ts

@@ -13,6 +13,14 @@ import './browser/workbench.contribution.js';
 //#endregion
 
 
+
+//#region --- Void
+// Void added this:
+import './contrib/void/browser/void.contribution.js';
+import '../platform/void/browser/llmMessageService.js';
+//#endregion
+
+
 //#region --- workbench actions
 
 import './browser/actions/textInputActions.js';