autocomplete UX

Added Ollama Model Check for installed models

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

CONTRIBUTING.md

@@ -1,15 +1,13 @@
 # Contributing to Void
 
-Welcome! 👋 This is a guide on how to contribute to Void. We want to make it as easy as possible to contribute, so if you have any questions or comments, reach out via email or discord!
+Welcome! 👋 This is the official guide on how to contribute to Void. We want to make it as easy as possible to contribute, so if you have any questions or comments, reach out via email or discord!
 
-There are two main ways to contribute:
+There are a few ways to contribute:
 
-- Suggest New Features ([discord](https://discord.gg/RSNjgaugJs))
-- Build New Features ([project](https://github.com/orgs/voideditor/projects/2/views/3))
+- 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).
 
 ## 1. Building the Extension
 
@@ -29,23 +27,52 @@ git clone https://github.com/voideditor/void
 npm install
 ```
 
-4. Compile the React by running `npm run build`. We created this build command to convert `sidebar/index.tsx` into `dist/`.
+1. Compile the React files by running `npm run build`. This build command converts all the Tailwind/React entrypoint files into raw .css and .js files in `dist/`.
 
 ```
 npm run build
 ```
 
-5. Run the project by pressing <kbd>F5</kbd>.
+5. Run the extension in a new window by pressing <kbd>F5</kbd>.
 
 This will start a new instance of VSCode with the extension enabled. If this doesn't work, you can press <kbd>Ctrl+Shift+P</kbd>, select "Debug: Start Debugging", and select "VSCode Extension Development".
 
 ## 2. Building the full IDE
 
-If you want to work on the full IDE, please follow the steps below. If you have any questions/issues, you can refer to VSCode's full [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page, which is where the steps below come from. Also feel free to submit an issue or get in touch with us with any build errors.
+If you want to work on the full IDE, please follow the steps below. If you have any questions/issues, you can refer to VSCode's full [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page. Also feel free to submit an issue or get in touch with us with any build errors.
 
-### a. Building on a Mac
+<!-- TODO say whether you can build each distribution on any Operating System, or if you need to build Windows on Windows, etc -->
 
-To build on a Mac, open `void/` in VSCode. Make sure you've built the extension by following the steps above (or just run `cd ./extensions/void && npm install && npm run build && npm run compile && cd ../..`). Also make sure you have Python and XCode installed on your system (you probably do by default).
+### a. Build Prerequisites - Mac
+
+If you're using a Mac, make sure you have Python and XCode installed (you probably do by default).
+
+### b. Build Prerequisites - Windows
+
+If you're using a Windows computer, first get [Visual Studio 2022](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community) (recommended) or [VS Build Tools](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools) (not recommended). If you already have both, you might need to run the next few steps on both of them.
+
+Open the installer for Visual Studio 2022 (or VS Build Tools). This is often automatic.
+
+Go to the "Workloads" tab and select:
+- `Desktop development with C++`
+- `Node.js build tools`
+
+Go to the "Individual Components" tab and select:
+- `MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs (Latest)`,
+- `C++ ATL for latest build tools with Spectre Mitigations`,
+- `C++ MFC for latest build tools with Spectre Mitigations`.
+
+Finally, click Install.
+
+### c. Build Prerequisites - Linux
+
+We haven't created prerequisite steps for building on Linux yet, but you can follow [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute).
+
+### Build instructions
+
+Before building Void, please follow the prerequisite steps above for your operating system. Also, make sure you've already built and compiled the Void extension (or just run `cd ./extensions/void && npm install && npm run build && npm run compile && cd ../..`).
+
+To build Void, first open `void/` in VSCode. Then:
 
 1. Install all dependencies.
 
@@ -53,9 +80,13 @@ To build on a Mac, open `void/` in VSCode. Make sure you've built the extension
 npm install
 ```
 
-2. Run `npm run watch`.
+2. Press <kbd>Ctrl+Shift+B</kbd>, or if you prefer using the terminal run `npm run watch`.
 
-This can take ~5 min. It's done when you see something like:
+This can take ~5 min.
+
+If you ran <kbd>Ctrl+Shift+B</kbd>, the build is done when you see two check marks.
+
+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
@@ -66,48 +97,37 @@ This can take ~5 min. It's done when you see something like:
 
 <!-- 3. Press <kbd>Ctrl+Shift+B</kbd> to start the build process. -->
 
-3. In a new terminal, run `./scripts/code.sh`.
-
-This should open up the built IDE after loading for some time. To see new changes without restarting the build, use <kbd>Ctrl+Shift+P</kbd> and run "Reload Window".
-
-To bundle the IDE, run `npm run gulp vscode-darwin-arm64`. Here are the full options: `vscode-{win32-ia32 | win32-x64 | darwin-x64 | darwin-arm64 | linux-ia32 | linux-x64 | linux-arm}(-min)`
+1. 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:**
+
+### Common Fixes
 
 - Make sure you have the same NodeJS version as `.nvmrc`.
 
-- If you see `X [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`
-
-### b. Building on Windows
-
-To build on Windows, please refer to [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute). We recommend building on Mac; we're Windows users who switch to Mac to build right now.
-
-<!-- Get [Visual Studio 2022](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community). Also find the boxes for "Desktop development with C++" and "Node.js development" and get those, too.
-
-If you get a node-gyp error in the next few steps, you should also get [Visual Studio Build Tools](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools), find the Visual Studio Build Tools box, click Install (or Modify), then in Individual Components:
-check every item under `MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs (Latest)`, `C++ ATL for latest build tools with Spectre Mitigations`, and `C++ MFC for latest build tools with Spectre Mitigations`.
+- 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.
 
 
-```
-npm config set msvs_version 2022
-```
- -->
+## 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)`
+
 
 ## Roadmap
 
-Here are the most important topics on our Roadmap. More ⭐'s = more important.
-
-These sometimes get outdated - please refer to our Issues page for the latest issues.
+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.
 
 ## ⭐⭐⭐ 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.
 
-## ⭐⭐⭐ Build Cursor-style quick edits (ctrl+k).
+## ⭐⭐⭐ 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.
+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.
 
 ## ⭐⭐⭐ Creative.
 
@@ -117,21 +137,19 @@ Eventually, we want to build a convenient API for creating AI tools. The API wil
 
 ## ⭐ One-stars.
 
-⭐ Let the user accept / reject all Diffs in an entire file via the sidebar.
+⭐ Let the user Accept / Reject all Diffs in an entire file via the sidebar.
 
 # 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. 
 
-- Try to avoid refactoring and making feature changes in the same PR.
+Please don't use AI to write your PR 🙂.
 
 # Relevant files
 
@@ -156,3 +174,8 @@ We keep track of all the files we've changed with Void so it's easy to rebase:
 - 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/RSNjgaugJs) or contact us via email.

extensions/void/.vscode/launch.json

@@ -10,7 +10,8 @@
 			"type": "extensionHost",
 			"request": "launch",
 			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}"
+				"--extensionDevelopmentPath=${workspaceFolder}",
+                "--enable-proposed-api=void.void",
 			],
 			"outFiles": [
 				"${workspaceFolder}/out/**/*.js"
@@ -18,4 +19,4 @@
 			"preLaunchTask": "${defaultBuildTask}"
 		}
 	]
-}
+}

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/build/build.js

@@ -0,0 +1,64 @@
+const tailwindcss = require('tailwindcss')
+const autoprefixer = require('autoprefixer')
+const postcss = require('postcss')
+const fs = require('fs')
+
+const convertTailwindToCSS = ({ from, to }) => {
+	console.log('converting ', from, ' --> ', to)
+
+	const original_css_contents = fs.readFileSync(from, 'utf8')
+
+	return 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)
+		})
+}
+
+
+const esbuild = require('esbuild')
+
+const convertTSXtoJS = async ({ from, to }) => {
+	console.log('converting ', from, ' --> ', to)
+
+	return esbuild.build({
+		entryPoints: [from],
+		bundle: true,
+		minify: true,
+		sourcemap: true,
+		outfile: to,
+		format: 'iife', // apparently iife is safe for browsers (safer than cjs)
+		platform: 'browser',
+		external: ['vscode'],
+	}).catch(() => process.exit(1));
+}
+
+(async () => {
+	// convert tsx to js
+	await convertTSXtoJS({
+		from: 'src/webviews/sidebar/index.tsx',
+		to: 'dist/webviews/sidebar/index.js',
+	})
+
+	await convertTSXtoJS({
+		from: 'src/webviews/ctrlk/index.tsx',
+		to: 'dist/webviews/ctrlk/index.js',
+	})
+
+	await convertTSXtoJS({
+		from: 'src/webviews/diffline/index.tsx',
+		to: 'dist/webviews/diffline/index.js',
+	})
+
+	// convert tailwind to css
+	await convertTailwindToCSS({
+		from: 'src/webviews/styles.css',
+		to: 'dist/webviews/styles.css',
+	})
+
+})()
+

extensions/void/package-lock.json

@@ -7,9 +7,16 @@
     "": {
       "name": "void",
       "version": "0.0.1",
+      "dependencies": {
+        "lru-cache": "^11.0.2",
+        "tree-sitter": "^0.21.1",
+        "tree-sitter-javascript": "^0.23.1",
+        "tree-sitter-python": "^0.23.4"
+      },
       "devDependencies": {
         "@anthropic-ai/sdk": "^0.29.2",
         "@eslint/js": "^9.9.1",
+        "@google/generative-ai": "^0.21.0",
         "@monaco-editor/react": "^4.6.0",
         "@rrweb/types": "^2.0.0-alpha.17",
         "@types/diff": "^5.2.2",
@@ -34,7 +41,6 @@
         "eslint-plugin-react": "^7.35.1",
         "eslint-plugin-react-hooks": "^4.6.2",
         "globals": "^15.9.0",
-        "lodash": "^4.17.21",
         "marked": "^14.1.0",
         "ollama": "^0.5.9",
         "openai": "^4.68.4",
@@ -737,6 +743,16 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@google/generative-ai": {
+      "version": "0.21.0",
+      "resolved": "https://registry.npmjs.org/@google/generative-ai/-/generative-ai-0.21.0.tgz",
+      "integrity": "sha512-7XhUbtnlkSEZK15kN3t+tzIMxsbKm/dSkKBFalj+20NvPKe1kBY7mR2P7vuijEn+f06z5+A8bVGKO0v39cr6Wg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
     "node_modules/@humanwhocodes/config-array": {
       "version": "0.13.0",
       "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz",
@@ -5025,12 +5041,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
-      "dev": true
-    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -5095,11 +5105,12 @@
       }
     },
     "node_modules/lru-cache": {
-      "version": "10.4.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
-      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "dev": true,
-      "license": "ISC"
+      "version": "11.0.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.0.2.tgz",
+      "integrity": "sha512-123qHRfJBmo2jXDbo/a5YOQrJoHF/GNQTLzQ5+IdK5pWpceK17yRc6ozlWd25FxvGKQbIUs91fDFkXmDHTKcyA==",
+      "engines": {
+        "node": "20 || >=22"
+      }
     },
     "node_modules/make-dir": {
       "version": "4.0.0",
@@ -6018,7 +6029,6 @@
       "resolved": "https://registry.npmjs.org/monaco-editor/-/monaco-editor-0.52.0.tgz",
       "integrity": "sha512-OeWhNpABLCeTqubfqLMXGsqf6OmPU6pHM85kF3dhy6kq5hnhuVS1p3VrEW/XhWHc71P2tHyS5JFySD8mgs1crw==",
       "dev": true,
-      "license": "MIT",
       "peer": true
     },
     "node_modules/ms": {
@@ -6066,6 +6076,14 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/node-addon-api": {
+      "version": "8.2.2",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.2.2.tgz",
+      "integrity": "sha512-9emqXAKhVoNrQ792nLI/wpzPpJ/bj/YXxW0CvAau1+RdGBcCRF1Dmz7719zgVsQNrzHl9Tzn3ImZ4qWFarWL0A==",
+      "engines": {
+        "node": "^18 || ^20 || >= 21"
+      }
+    },
     "node_modules/node-domexception": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
@@ -6107,6 +6125,16 @@
         }
       }
     },
+    "node_modules/node-gyp-build": {
+      "version": "4.8.3",
+      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.3.tgz",
+      "integrity": "sha512-EMS95CMJzdoSKoIiXo8pxKoL8DYxwIZXYlLmgPb8KUv794abpnLK6ynsCAWNliOjREKruYKdzbh76HHYUHX7nw==",
+      "bin": {
+        "node-gyp-build": "bin.js",
+        "node-gyp-build-optional": "optional.js",
+        "node-gyp-build-test": "build-test.js"
+      }
+    },
     "node_modules/node-releases": {
       "version": "2.0.18",
       "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
@@ -6608,6 +6636,12 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/path-scurry/node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true
+    },
     "node_modules/picocolors": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
@@ -7448,16 +7482,6 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/rimraf/node_modules/lru-cache": {
-      "version": "11.0.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.0.1.tgz",
-      "integrity": "sha512-CgeuL5uom6j/ZVrg7G/+1IXqRY8JXX4Hghfy5YE0EhoYQWvndP1kufu58cmZLNIDKnRhZrXfdS9urVWx98AipQ==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
     "node_modules/rimraf/node_modules/minimatch": {
       "version": "10.0.1",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.1.tgz",
@@ -8256,6 +8280,52 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/tree-sitter": {
+      "version": "0.21.1",
+      "resolved": "https://registry.npmjs.org/tree-sitter/-/tree-sitter-0.21.1.tgz",
+      "integrity": "sha512-7dxoA6kYvtgWw80265MyqJlkRl4yawIjO7S5MigytjELkX43fV2WsAXzsNfO7sBpPPCF5Gp0+XzHk0DwLCq3xQ==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "node-addon-api": "^8.0.0",
+        "node-gyp-build": "^4.8.0"
+      }
+    },
+    "node_modules/tree-sitter-javascript": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/tree-sitter-javascript/-/tree-sitter-javascript-0.23.1.tgz",
+      "integrity": "sha512-/bnhbrTD9frUYHQTiYnPcxyHORIw157ERBa6dqzaKxvR/x3PC4Yzd+D1pZIMS6zNg2v3a8BZ0oK7jHqsQo9fWA==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "node-addon-api": "^8.2.2",
+        "node-gyp-build": "^4.8.2"
+      },
+      "peerDependencies": {
+        "tree-sitter": "^0.21.1"
+      },
+      "peerDependenciesMeta": {
+        "tree-sitter": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tree-sitter-python": {
+      "version": "0.23.4",
+      "resolved": "https://registry.npmjs.org/tree-sitter-python/-/tree-sitter-python-0.23.4.tgz",
+      "integrity": "sha512-MbmUAl7y5UCUWqHscHke7DdRDwQnVNMNKQYQc4Gq2p09j+fgPxaU8JVsuOI/0HD3BSEEe5k9j3xmdtIWbDtDgw==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "node-addon-api": "^8.2.1",
+        "node-gyp-build": "^4.8.2"
+      },
+      "peerDependencies": {
+        "tree-sitter": "^0.21.1"
+      },
+      "peerDependenciesMeta": {
+        "tree-sitter": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/trim-lines": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",

extensions/void/package.json

@@ -10,14 +10,21 @@
   "categories": [
     "Other"
   ],
+  "enabledApiProposals": [
+    "editorInsets"
+  ],
   "activationEvents": [],
-  "main": "./out/extension.js",
+  "main": "./out/extension/extension.js",
   "contributes": {
     "configuration": {
       "title": "Void",
       "properties": {}
     },
     "commands": [
+      {
+        "command": "typeInspector.inspect",
+        "title": "Inspect Types of All Variables"
+      },
       {
         "command": "void.ctrl+l",
         "title": "Show Sidebar"
@@ -104,13 +111,14 @@
     "vscode:prepublish": "npm run compile",
     "compile": "tsc -p ./",
     "watch": "tsc -watch -p ./",
-    "build": "rimraf dist && node build-tsx.js && node build-css.js",
+    "build": "rimraf dist && node build/build.js",
     "pretest": "tsc -p ./ && eslint src --ext ts",
     "test": "vscode-test"
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.29.2",
     "@eslint/js": "^9.9.1",
+    "@google/generative-ai": "^0.21.0",
     "@monaco-editor/react": "^4.6.0",
     "@rrweb/types": "^2.0.0-alpha.17",
     "@types/diff": "^5.2.2",
@@ -135,7 +143,6 @@
     "eslint-plugin-react": "^7.35.1",
     "eslint-plugin-react-hooks": "^4.6.2",
     "globals": "^15.9.0",
-    "lodash": "^4.17.21",
     "marked": "^14.1.0",
     "ollama": "^0.5.9",
     "openai": "^4.68.4",
@@ -151,5 +158,11 @@
     "typescript": "5.5.4",
     "typescript-eslint": "^8.3.0",
     "uuid": "^10.0.0"
+  },
+  "dependencies": {
+    "lru-cache": "^11.0.2",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-javascript": "^0.23.1",
+    "tree-sitter-python": "^0.23.4"
   }
 }

extensions/void/src/SidebarWebviewProvider.ts

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

@@ -0,0 +1,114 @@
+import { configFields, VoidConfig } from "../webviews/common/contextForConfig"
+import { FimInfo } from "./sendLLMMessage"
+
+
+type GetFIMPrompt = ({ voidConfig, fimInfo }: { voidConfig: VoidConfig, fimInfo: FimInfo, }) => string
+
+export const getFIMSystem: GetFIMPrompt = ({ voidConfig, fimInfo }) => {
+
+	switch (voidConfig.default.whichApi) {
+		case 'ollama':
+			return ''
+		case 'anthropic':
+		case 'openAI':
+		case 'gemini':
+		case 'greptile':
+		case 'openRouter':
+		case 'openAICompatible':
+		case 'azure':
+		default:
+			return `You are given the START and END to a piece of code. Please FILL IN THE MIDDLE between the START and END.
+
+Instruction summary:
+1. Return the MIDDLE of the code between the START and END.
+2. Do not give an explanation, description, or any other code besides the middle.
+3. Do not return duplicate code from either START or END.
+4. Make sure the MIDDLE piece of code has balanced brackets that match the START and END.
+5. The MIDDLE begins on the same line as START. Please include a newline character if you want to begin on the next line.
+6. Around 90% of the time, you should return just one or a few lines of code. You should keep your outputs short unless you are confident the user is trying to write boilderplate code.
+
+# EXAMPLE
+
+## START:
+\`\`\` python
+def add(a,b):
+	return a + b
+def subtract(a,b):
+	return a - b
+\`\`\`
+## END:
+\`\`\` python
+def divide(a,b):
+	return a / b
+\`\`\`
+## EXPECTED OUTPUT:
+\`\`\` python
+
+def multiply(a,b):
+	return a * b
+\`\`\`
+
+# EXAMPLE
+## START:
+\`\`\` javascript
+const x = 1
+
+const y
+\`\`\`
+## END:
+\`\`\` javascript
+
+const z = 3
+\`\`\`
+## EXPECTED OUTPUT:
+\`\`\` javascript
+= 2
+\`\`\`
+`
+	}
+
+
+}
+
+
+export const getFIMPrompt: GetFIMPrompt = ({ voidConfig, fimInfo }) => {
+
+	const { prefix: fullPrefix, suffix: fullSuffix } = fimInfo
+	const prefix = fullPrefix.split('\n').slice(-20).join('\n')
+	const suffix = fullSuffix.split('\n').slice(0, 20).join('\n')
+
+
+	console.log('prefix', JSON.stringify(prefix))
+	console.log('suffix', JSON.stringify(suffix))
+
+	if (!prefix.trim() && !suffix.trim()) return ''
+
+	// TODO may want to trim the prefix and suffix
+	switch (voidConfig.default.whichApi) {
+		case 'ollama':
+			if (voidConfig.ollama.model === 'codestral') {
+				return `[SUFFIX]${suffix}[PREFIX] ${prefix}`
+			} else if (voidConfig.ollama.model.includes('qwen')) {
+				return `<|fim_prefix|>${prefix}<|fim_suffix|>${suffix}<|fim_middle|>`
+			}
+			return ''
+		case 'anthropic':
+		case 'openAI':
+		case 'gemini':
+		case 'greptile':
+		case 'openRouter':
+		case 'openAICompatible':
+		case 'azure':
+		default:
+			return `## START:
+\`\`\`
+${prefix}
+\`\`\`
+## END:
+\`\`\`
+${suffix}
+\`\`\`
+`
+	}
+}
+

extensions/void/src/common/sendLLMMessage.ts

@@ -1,9 +1,11 @@
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import { Ollama } from 'ollama/browser'
-import { VoidConfig } from '../sidebar/contextForConfig';
+import { Content, GoogleGenerativeAI, GoogleGenerativeAIError, GoogleGenerativeAIFetchError } from '@google/generative-ai';
+import { VoidConfig } from '../webviews/common/contextForConfig'
+import { getFIMPrompt, getFIMSystem } from './getPrompt';
 
-export type AbortRef = { current: (() => void) | null }
+export type AbortRef = { current: (() => void) }
 
 export type OnText = (newText: string, fullText: string) => void
 
@@ -19,26 +21,44 @@ export type LLMMessage = {
 	content: string,
 }
 
+type LLMMessageOptions = { stopTokens?: string[] }
+
 type SendLLMMessageFnTypeInternal = (params: {
+	mode: 'chat' | 'fim',
 	messages: LLMMessage[],
+	options?: LLMMessageOptions,
 	onText: OnText,
 	onFinalMessage: OnFinalMessage,
 	onError: (error: string) => void,
+	abortRef: AbortRef,
 	voidConfig: VoidConfig,
-	abortRef: AbortRef,
 }) => void
 
-type SendLLMMessageFnTypeExternal = (params: {
-	messages: LLMMessage[],
+
+type SendLLMMessageFnTypeExternal = (params: (
+	| { mode?: 'chat', messages: LLMMessage[], fimInfo?: undefined, }
+	| { mode: 'fim', messages?: undefined, fimInfo: FimInfo, }
+) & {
+	options?: LLMMessageOptions,
 	onText: OnText,
-	onFinalMessage: (fullText: string) => void,
+	onFinalMessage: OnFinalMessage,
 	onError: (error: string) => void,
-	voidConfig: VoidConfig | null,
 	abortRef: AbortRef,
+	voidConfig: VoidConfig | null, // these may be absent
 }) => void
 
+export type FimInfo = {
+	prefix: string,
+	suffix: string,
+}
 
-
+const parseMaxTokensStr = (maxTokensStr: string) => {
+	// parse the string but only if the full string is a valid number, eg parseInt('100abc') should return NaN
+	let int = isNaN(Number(maxTokensStr)) ? undefined : parseInt(maxTokensStr)
+	if (Number.isNaN(int))
+		return undefined
+	return int
+}
 
 // Anthropic
 const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
@@ -58,7 +78,7 @@ const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFi
 		system: systemMessage,
 		messages: anthropicMessages,
 		model: voidConfig.anthropic.model,
-		max_tokens: parseInt(voidConfig.default.maxTokens),
+		max_tokens: parseMaxTokensStr(voidConfig.default.maxTokens)!, // this might be undefined, but it will just throw an error for the user
 	});
 
 	let did_abort = false
@@ -96,8 +116,62 @@ const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFi
 	return { abort }
 };
 
+// Gemini
+const sendGeminiMsg: SendLLMMessageFnTypeInternal = async ({ messages, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
 
+	let didAbort = false
+	let fullText = ''
 
+	abortRef.current = () => {
+		didAbort = true
+	}
+
+	const genAI = new GoogleGenerativeAI(voidConfig.gemini.apikey);
+	const model = genAI.getGenerativeModel({ model: voidConfig.gemini.model });
+
+	// remove system messages that get sent to Gemini
+	// str of all system messages
+	let 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 => {
+			abortRef.current = () => {
+				// response.stream.return(fullText)
+				didAbort = true;
+			}
+			for await (const chunk of response.stream) {
+				if (didAbort) return;
+				const newText = chunk.text();
+				fullText += newText;
+				onText(newText, fullText);
+			}
+			onFinalMessage(fullText);
+		})
+		.catch((error) => {
+			if (error instanceof GoogleGenerativeAIFetchError) {
+				if (error.status === 400) {
+					onError('Invalid API key.');
+				}
+				else {
+					onError(`${error.name}:\n${error.message}`);
+				}
+			}
+			else {
+				onError(error);
+			}
+		})
+}
 
 // OpenAI, OpenRouter, OpenAICompatible
 const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
@@ -113,9 +187,11 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 	let openai: OpenAI
 	let options: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
 
+	let maxTokens = parseMaxTokensStr(voidConfig.default.maxTokens)
+
 	if (voidConfig.default.whichApi === 'openAI') {
 		openai = new OpenAI({ apiKey: voidConfig.openAI.apikey, dangerouslyAllowBrowser: true });
-		options = { model: voidConfig.openAI.model, messages: messages, stream: true, max_completion_tokens: parseInt(voidConfig.default.maxTokens) }
+		options = { model: voidConfig.openAI.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
 	}
 	else if (voidConfig.default.whichApi === 'openRouter') {
 		openai = new OpenAI({
@@ -125,11 +201,11 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 				"X-Title": 'Void Editor', // Optional. Shows in rankings on openrouter.ai.
 			},
 		});
-		options = { model: voidConfig.openRouter.model, messages: messages, stream: true, max_completion_tokens: parseInt(voidConfig.default.maxTokens) }
+		options = { model: voidConfig.openRouter.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
 	}
 	else if (voidConfig.default.whichApi === 'openAICompatible') {
 		openai = new OpenAI({ baseURL: voidConfig.openAICompatible.endpoint, apiKey: voidConfig.openAICompatible.apikey, dangerouslyAllowBrowser: true })
-		options = { model: voidConfig.openAICompatible.model, messages: messages, stream: true, max_completion_tokens: parseInt(voidConfig.default.maxTokens) }
+		options = { model: voidConfig.openAICompatible.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
 	}
 	else {
 		console.error(`sendOpenAIMsg: invalid whichApi: ${voidConfig.default.whichApi}`)
@@ -159,7 +235,7 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 					onError('Invalid API key.');
 				}
 				else {
-					onError(error.message);
+					onError(`${error.name}:\n${error.message}`);
 				}
 			}
 			else {
@@ -169,50 +245,85 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 
 };
 
-
 // Ollama
-export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
+export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ options, mode, messages, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
 
 	let didAbort = false
 	let fullText = ""
 
-	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
+	const ollama = new Ollama({ host: voidConfig.ollama.endpoint })
+
 	abortRef.current = () => {
 		didAbort = true;
 	};
 
-	const ollama = new Ollama({ host: voidConfig.ollama.endpoint })
+	type GenerateResponse = Awaited<ReturnType<(typeof ollama.generate)>>
+	type ChatResponse = Awaited<ReturnType<(typeof ollama.chat)>>
 
-	ollama.chat({
-		model: voidConfig.ollama.model,
-		messages: messages,
-		stream: true,
-		options: { num_predict: parseInt(voidConfig.default.maxTokens) } // this is max_tokens
-	})
-		.then(async stream => {
-			abortRef.current = () => {
-				// stream.abort()
-				didAbort = true
+
+	// First check if model exists
+	ollama.list()
+		.then(async models => {
+			const installedModels = models.models.map(m => m.name.replace(/:latest$/, ''))
+			const modelExists = installedModels.some(m => m.startsWith(voidConfig.ollama.model));
+			if (!modelExists) {
+				const errorMessage = `The model "${voidConfig.ollama.model}" is not available locally. Please run 'ollama pull ${voidConfig.ollama.model}' to download it first or
+				try selecting one from the Installed models: ${installedModels.join(', ')}`;
+				onText(errorMessage, errorMessage);
+				onFinalMessage(errorMessage);
+				return Promise.reject();
+			}
+
+			if (mode === 'fim') {
+				// the fim prompt is the last message
+				let prompt = messages[messages.length - 1].content
+				return ollama.generate({
+					model: voidConfig.ollama.model,
+					prompt: prompt,
+					stream: true,
+					raw: true,
+					options: { stop: options?.stopTokens }
+				})
+			}
+
+			return ollama.chat({
+				model: voidConfig.ollama.model,
+				messages: messages,
+				stream: true,
+				options: { num_predict: parseMaxTokensStr(voidConfig.default.maxTokens) }
+			});
+		})
+		.then(async stream => {
+			if (!stream) return;
+
+			abortRef.current = () => {
+				didAbort = true
+				stream.abort()
 			}
-			// iterate through the stream
 			for await (const chunk of stream) {
 				if (didAbort) return;
-				const newText = chunk.message.content;
+
+				const newText = (mode === 'fim'
+					? (chunk as GenerateResponse).response
+					: (chunk as ChatResponse).message.content
+				)
 				fullText += newText;
 				onText(newText, fullText);
 			}
 			onFinalMessage(fullText);
-
 		})
-		// when error/fail
 		.catch(error => {
-			onError(error)
-		})
-
+			// Check if the error is a connection error
+			if (error instanceof Error && error.message.includes('Failed to fetch')) {
+				const errorMessage = 'Ollama service is not running. Please start the Ollama service and try again.';
+				onText(errorMessage, errorMessage);
+				onFinalMessage(errorMessage);
+			} else if (error) {
+				onError(error);
+			}
+		});
 };
 
-
-
 // Greptile
 // https://docs.greptile.com/api-reference/query
 // https://docs.greptile.com/quickstart#sample-response-streamed
@@ -227,7 +338,6 @@ const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFin
 		didAbort = true
 	}
 
-
 	fetch('https://api.greptile.com/v2/query', {
 		method: 'POST',
 		headers: {
@@ -282,26 +392,51 @@ const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFin
 
 }
 
+export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ options, mode, messages, fimInfo, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
+	if (!voidConfig)
+		return onError('No config file found for LLM.');
 
+	// handle defaults
+	if (!mode) mode = 'chat'
+	if (!messages) messages = []
 
-export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
-	if (!voidConfig) return;
+	// build messages
+	if (mode === 'chat') {
+		// nothing needed
+	} else if (mode === 'fim') {
+		fimInfo = fimInfo!
+
+		const system = getFIMSystem({ voidConfig, fimInfo })
+		const prompt = getFIMPrompt({ voidConfig, fimInfo })
+		messages = ([
+			{ role: 'system', content: system },
+			{ role: 'user', content: prompt }
+		] as const)
+
+	}
 
 	// trim message content (Anthropic and other providers give an error if there is trailing whitespace)
 	messages = messages.map(m => ({ ...m, content: m.content.trim() }))
+		.filter(m => m.content !== '')
+
+	if (messages.length === 0)
+		return onError('No messages provided to LLM.');
 
 	switch (voidConfig.default.whichApi) {
 		case 'anthropic':
-			return sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
+			return sendAnthropicMsg({ options, mode, messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'openAI':
 		case 'openRouter':
 		case 'openAICompatible':
-			return sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
+			return sendOpenAIMsg({ options, mode, messages, onText, onFinalMessage, onError, voidConfig, abortRef });
+		case 'gemini':
+			return sendGeminiMsg({ options, mode, messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'ollama':
-			return sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
+			return sendOllamaMsg({ options, mode, messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'greptile':
-			return sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
+			return sendGreptileMsg({ options, mode, messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		default:
 			onError(`Error: whichApi was ${voidConfig.default.whichApi}, which is not recognized!`)
 	}
+
 }

extensions/void/src/common/shared_types.ts

@@ -1,11 +1,8 @@
 
 import * as vscode from 'vscode';
-import { PartialVoidConfig } from '../sidebar/contextForConfig';
+import { PartialVoidConfig } from '../webviews/common/contextForConfig'
 
-
-
-// a selection is a frozen snapshot
-type CodeSelection = { selectionStr: string, selectionRange: vscode.Range, filePath: vscode.Uri }
+type CodeSelection = { selectionStr: string, filePath: vscode.Uri }
 
 type File = { filepath: vscode.Uri, content: string }
 
@@ -37,7 +34,7 @@ type Diff = {
 
 // editor -> sidebar
 type MessageToSidebar = (
-	| { type: 'ctrl+l', selection: CodeSelection } // user presses ctrl+l in the editor
+	| { type: 'ctrl+l', selection: CodeSelection } // user presses ctrl+l in the editor. selection and path are frozen snapshots
 	| { type: 'ctrl+k', selection: CodeSelection }
 	| { type: 'files', files: { filepath: vscode.Uri, content: string }[] }
 	| { type: 'partialVoidConfig', partialVoidConfig: PartialVoidConfig }

extensions/void/src/common/systemPrompts.ts

@@ -1,4 +1,14 @@
 
+
+
+// used for ctrl+l
+const partialGenerationInstructions = ``
+
+
+// used for ctrl+k, autocomplete
+const fimInstructions = ``
+
+
 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\`.
 
@@ -399,6 +409,7 @@ export default Sidebar;\`\`\`
 
 
 
+
 export {
 	generateDiffInstructions,
 	searchDiffChunkInstructions,

extensions/void/src/extension/AutcompleteProvider.ts

@@ -0,0 +1,467 @@
+import * as vscode from 'vscode';
+import { AbortRef, LLMMessage, sendLLMMessage } from '../common/sendLLMMessage';
+import { getVoidConfigFromPartial, VoidConfig } from '../webviews/common/contextForConfig';
+import { LRUCache } from 'lru-cache';
+
+
+/*
+A summary of autotab:
+
+Postprocessing
+-one common problem for all models is outputting unbalanced parentheses
+we solve this by trimming all extra closing parentheses from the generated string
+in future, should make sure parentheses are always balanced
+
+-another problem is completing the middle of a string, eg. "const [x, CURSOR] = useState()"
+we complete up to first matchup character
+but should instead complete the whole line / block (difficult because of parenthesis accuracy)
+
+-too much info is bad. usually we want to show the user 1 line, and have a preloaded response afterwards
+this should happen automatically with caching system
+should break preloaded responses into \n\n chunks
+
+Preprocessing
+- we don't generate if cursor is at end / beginning of a line (no spaces)
+- we generate 1 line if there is text to the right of cursor
+- we generate 1 line if variable declaration
+- (in many cases want to show 1 line but generate multiple)
+
+State
+- cache based on prefix (and do some trimming first)
+- when press tab on one line, should have an immediate followup response
+to do this, show autocompletes before they're fully finished
+- [todo] remove each autotab when accepted
+- [todo] treat windows \r\n separately from \n
+!- [todo] provide type information
+
+Details
+-generated results are trimmed up to 1 leading/trailing space
+-prefixes are cached up to 1 trailing newline
+-
+*/
+
+
+
+
+
+type AutocompletionStatus = 'pending' | 'finished' | 'error';
+type Autocompletion = {
+	id: number,
+	prefix: string,
+	suffix: string,
+	startTime: number,
+	endTime: number | undefined,
+	abortRef: AbortRef,
+	status: AutocompletionStatus,
+	llmPromise: Promise<string> | undefined,
+	result: string,
+}
+
+const DEBOUNCE_TIME = 500
+const TIMEOUT_TIME = 60000
+const MAX_CACHE_SIZE = 20
+const MAX_PENDING_REQUESTS = 2
+
+// postprocesses the result
+const postprocessResult = (result: string) => {
+
+	console.log('result: ', JSON.stringify(result))
+
+	// trim all whitespace except for a single leading/trailing space
+	const hasLeadingSpace = result.startsWith(' ');
+	const hasTrailingSpace = result.endsWith(' ');
+	return (hasLeadingSpace ? ' ' : '')
+		+ result.trim()
+		+ (hasTrailingSpace ? ' ' : '');
+
+}
+
+const extractCodeFromResult = (result: string) => {
+
+	// extract the code between triple backticks
+	const parts = result.split(/```(?:\s*\w+)?\n?/);
+
+	// if there is no ``` then return the raw result
+	if (parts.length === 1) {
+		return result;
+	}
+
+	// else return the code between the triple backticks
+	return parts[1]
+
+}
+
+// trims the end of the prefix to improve cache hit rate
+const trimPrefix = (prefix: string) => {
+	const trimmedPrefix = prefix.trimEnd()
+	const trailingEnd = prefix.substring(trimmedPrefix.length)
+
+	// keep only a single trailing newline
+	if (trailingEnd.includes('\n')) {
+		return trimmedPrefix + '\n'
+	}
+
+	// else ignore all spaces and return the trimmed prefix
+	return trimmedPrefix
+}
+
+function getStringUpToUnbalancedParenthesis(s: string, prefixToTheLeft: string): string {
+
+	const pairs: Record<string, string> = { ')': '(', '}': '{', ']': '[' };
+
+	// todo find first open bracket in prefix and get all brackets beyond it in prefix
+	// get all bracets in prefix
+	let stack: string[] = []
+	const firstOpenIdx = prefixToTheLeft.search(/[[({]/);
+	if (firstOpenIdx !== -1) stack = prefixToTheLeft.slice(firstOpenIdx).split('').filter(c => '()[]{}'.includes(c))
+
+	// Iterate through each character
+	for (let i = 0; i < s.length; i++) {
+		const char = s[i];
+
+		if (char === '(' || char === '{' || char === '[') { stack.push(char); }
+		else if (char === ')' || char === '}' || char === ']') {
+			if (stack.length === 0 || stack.pop() !== pairs[char]) { return s.substring(0, i); }
+		}
+	}
+	return s;
+}
+
+// finds the text in the autocompletion to display, assuming the prefix is already matched
+// example:
+// originalPrefix = abcd
+// generatedMiddle = efgh
+// originalSuffix = ijkl
+// the user has typed "ef" so prefix = abcdef
+// we want to return the rest of the generatedMiddle, which is "gh"
+const toInlineCompletion = ({ prefix, suffix, autocompletion, position }: { prefix: string, suffix: string, autocompletion: Autocompletion, position: vscode.Position }): vscode.InlineCompletionItem => {
+	const originalPrefix = autocompletion.prefix
+	const generatedMiddle = autocompletion.result
+
+	const trimmedOriginalPrefix = trimPrefix(originalPrefix)
+	const trimmedCurrentPrefix = trimPrefix(prefix)
+
+	const suffixLines = suffix.split('\n')
+	const prefixLines = trimmedCurrentPrefix.split('\n')
+	const suffixToTheRightOfCursor = suffixLines[0].trim()
+	const prefixToTheLeftOfCursor = prefixLines[prefixLines.length - 1].trim()
+
+	const generatedLines = generatedMiddle.split('\n')
+
+	// compute startIdx
+	let startIdx = trimmedCurrentPrefix.length - trimmedOriginalPrefix.length
+	if (startIdx < 0) {
+		return new vscode.InlineCompletionItem('')
+	}
+
+	// compute endIdx
+	// hacks to get the suffix to render properly with lower quality models
+	// if the generated text matches with the suffix on the current line, stop
+	let endIdx: number | undefined = generatedMiddle.length // exclusive bounds
+
+	if (suffixToTheRightOfCursor !== '') { // completing in the middle of a line
+		console.log('1')
+		// complete until there is a match
+		const matchIndex = generatedMiddle.lastIndexOf(suffixToTheRightOfCursor[0])
+		if (matchIndex > 0) { endIdx = matchIndex }
+	}
+
+	if (prefixToTheLeftOfCursor !== '') { // completing the end of a line
+		console.log('2')
+		// show a single line
+		const newlineIdx = generatedMiddle.indexOf('\n')
+		if (newlineIdx > -1) { endIdx = newlineIdx }
+	}
+
+	// // if a generated line matches with a suffix line, stop
+	// if (suffixLines.length > 1) {
+	// 	console.log('3')
+	// 	const lines = []
+	// 	for (const generatedLine of generatedLines) {
+	// 		if (suffixLines.slice(0, 10).some(suffixLine =>
+	// 			generatedLine.trim() !== '' && suffixLine.trim() !== ''
+	// 			&& generatedLine.trim().startsWith(suffixLine.trim())
+	// 		)) break;
+	// 		lines.push(generatedLine)
+	// 	}
+	// 	endIdx = lines.join('\n').length // this is hacky, remove or refactor in future
+	// }
+
+	let completionStr = generatedMiddle.slice(startIdx, endIdx)
+
+	// filter out unbalanced parentheses
+	console.log('completionStrBeforeParens: ', JSON.stringify(completionStr))
+	completionStr = getStringUpToUnbalancedParenthesis(completionStr, prefixLines.slice(-2).join('\n'))
+
+	console.log('originalCompletionStr: ', JSON.stringify(generatedMiddle.slice(startIdx)))
+	console.log('finalCompletionStr: ', JSON.stringify(completionStr))
+
+	return new vscode.InlineCompletionItem(completionStr, new vscode.Range(position, position))
+
+}
+
+// returns whether this autocompletion is in the cache
+const doesPrefixMatchAutocompletion = ({ prefix, autocompletion }: { prefix: string, autocompletion: Autocompletion }): boolean => {
+
+	const originalPrefix = autocompletion.prefix
+	const generatedMiddle = autocompletion.result
+	const originalPrefixTrimmed = trimPrefix(originalPrefix)
+	const currentPrefixTrimmed = trimPrefix(prefix)
+
+	if (currentPrefixTrimmed.length < originalPrefixTrimmed.length) {
+		return false
+	}
+
+	const isMatch = (originalPrefixTrimmed + generatedMiddle).startsWith(currentPrefixTrimmed)
+	return isMatch
+
+}
+
+const getCompletionOptions = ({ prefix, suffix }: { prefix: string, suffix: string }) => {
+
+	const prefixLines = prefix.split('\n')
+	const suffixLines = suffix.split('\n')
+
+	const prefixToLeftOfCursor = prefixLines.slice(-1)[0] ?? ''
+	const suffixToRightOfCursor = suffixLines[0]
+
+	// default parameters
+	let shouldGenerate = true
+	let stopTokens: string[] = ['\n\n', '\r\n\r\n']
+
+	// specific cases
+	if (suffixToRightOfCursor.trim() !== '') { // typing between something
+		stopTokens = ['\n', '\r\n']
+	}
+
+	// if (prefixToLeftOfCursor.trim() === '' && suffixToRightOfCursor.trim() === '') { // at an empty line
+	// 	stopTokens = ['\n\n', '\r\n\r\n']
+	// }
+
+	if (prefixToLeftOfCursor === '' || suffixToRightOfCursor === '') { // at beginning or end of line
+		shouldGenerate = false
+	}
+
+	console.log('shouldGenerate:', shouldGenerate, stopTokens)
+
+	return { shouldGenerate, stopTokens }
+
+}
+
+export class AutocompleteProvider implements vscode.InlineCompletionItemProvider {
+
+	private _extensionContext: vscode.ExtensionContext;
+
+	private _autocompletionId: number = 0;
+	private _autocompletionsOfDocument: { [docUriStr: string]: LRUCache<number, Autocompletion> } = {}
+
+	private _lastCompletionTime = 0
+	private _lastPrefix: string = ''
+
+	constructor(context: vscode.ExtensionContext) {
+		this._extensionContext = context
+	}
+
+	// used internally by vscode
+	// fires after every keystroke and returns the completion to show
+	async provideInlineCompletionItems(
+		document: vscode.TextDocument,
+		position: vscode.Position,
+		context: vscode.InlineCompletionContext,
+		token: vscode.CancellationToken,
+	): Promise<vscode.InlineCompletionItem[]> {
+
+		const disabled = false
+		if (disabled) { return []; }
+
+		const docUriStr = document.uri.toString()
+
+
+		const fullText = document.getText();
+		const cursorOffset = document.offsetAt(position);
+		const prefix = fullText.substring(0, cursorOffset)
+		const suffix = fullText.substring(cursorOffset)
+		const voidConfig = getVoidConfigFromPartial(this._extensionContext.globalState.get('partialVoidConfig') ?? {})
+
+		// initialize cache and other variables
+		// note that whenever an autocompletion is rejected, it is removed from cache
+		if (!this._autocompletionsOfDocument[docUriStr]) {
+			this._autocompletionsOfDocument[docUriStr] = new LRUCache<number, Autocompletion>({
+				max: MAX_CACHE_SIZE,
+				dispose: (autocompletion) => {
+					autocompletion.abortRef.current()
+				}
+			})
+		}
+		this._lastPrefix = prefix
+
+		// get all pending autocompletions
+		let __c = 0
+		this._autocompletionsOfDocument[docUriStr].forEach(a => { if (a.status === 'pending') __c += 1 })
+		console.log('pending: ' + __c)
+
+		// get autocompletion from cache
+		let cachedAutocompletion: Autocompletion | undefined = undefined
+		for (const autocompletion of this._autocompletionsOfDocument[docUriStr].values()) {
+			// if the user's change matches up with the generated text
+			if (doesPrefixMatchAutocompletion({ prefix, autocompletion })) {
+				cachedAutocompletion = autocompletion
+				break
+			}
+		}
+
+		// if there is a cached autocompletion, return it
+		if (cachedAutocompletion) {
+
+			if (cachedAutocompletion.status === 'finished') {
+				console.log('A1')
+
+				const inlineCompletion = toInlineCompletion({ autocompletion: cachedAutocompletion, prefix, suffix, position })
+				return [inlineCompletion]
+
+			} else if (cachedAutocompletion.status === 'pending') {
+				console.log('A2')
+
+				try {
+					await cachedAutocompletion.llmPromise;
+					console.log('id: ' + cachedAutocompletion.id)
+					const inlineCompletion = toInlineCompletion({ autocompletion: cachedAutocompletion, prefix, suffix, position })
+					return [inlineCompletion]
+
+				} catch (e) {
+					this._autocompletionsOfDocument[docUriStr].delete(cachedAutocompletion.id)
+					console.error('Error creating autocompletion (1): ' + e)
+				}
+
+			} else if (cachedAutocompletion.status === 'error') {
+				console.log('A3')
+			}
+
+			return []
+		}
+
+		// else if no more typing happens, then go forwards with the request
+		// wait DEBOUNCE_TIME for the user to stop typing
+		const thisTime = Date.now()
+		this._lastCompletionTime = thisTime
+		const didTypingHappenDuringDebounce = await new Promise((resolve, reject) =>
+			setTimeout(() => {
+				if (this._lastCompletionTime === thisTime) {
+					resolve(false)
+				} else {
+					resolve(true)
+				}
+			}, DEBOUNCE_TIME)
+		)
+
+		// if more typing happened, then do not go forwards with the request
+		if (didTypingHappenDuringDebounce) {
+			return []
+		}
+
+		console.log('B')
+
+		// if there are too many pending requests, cancel the oldest one
+		let numPending = 0
+		let oldestPending: Autocompletion | undefined = undefined
+		for (const autocompletion of this._autocompletionsOfDocument[docUriStr].values()) {
+			if (autocompletion.status === 'pending') {
+				numPending += 1
+				if (oldestPending === undefined) {
+					oldestPending = autocompletion
+				}
+				if (numPending >= MAX_PENDING_REQUESTS) {
+					// cancel the oldest pending request and remove it from cache
+					this._autocompletionsOfDocument[docUriStr].delete(oldestPending.id)
+					break
+				}
+			}
+		}
+
+		const { shouldGenerate, stopTokens } = getCompletionOptions({ prefix, suffix })
+
+		if (!shouldGenerate) return []
+
+		// create a new autocompletion and add it to cache
+		const newAutocompletion: Autocompletion = {
+			id: this._autocompletionId++,
+			prefix: prefix,
+			suffix: suffix,
+			startTime: Date.now(),
+			endTime: undefined,
+			abortRef: { current: () => { } },
+			status: 'pending',
+			llmPromise: undefined,
+			result: '',
+		}
+
+		// set parameters of `newAutocompletion` appropriately
+		newAutocompletion.llmPromise = new Promise((resolve, reject) => {
+
+			sendLLMMessage({
+				mode: 'fim',
+				fimInfo: { prefix, suffix },
+				options: { stopTokens },
+				onText: async (tokenStr, completionStr) => {
+
+					newAutocompletion.result = completionStr
+
+					// if generation doesn't match the prefix for the first few tokens generated, reject it
+					if (!doesPrefixMatchAutocompletion({ prefix: this._lastPrefix, autocompletion: newAutocompletion })) {
+						reject('LLM response did not match user\'s text.')
+					}
+				},
+				onFinalMessage: (finalMessage) => {
+
+					// newAutocompletion.prefix = prefix
+					// newAutocompletion.suffix = suffix
+					// newAutocompletion.startTime = Date.now()
+					newAutocompletion.endTime = Date.now()
+					// newAutocompletion.abortRef = { current: () => { } }
+					newAutocompletion.status = 'finished'
+					// newAutocompletion.promise = undefined
+					newAutocompletion.result = postprocessResult(extractCodeFromResult(finalMessage))
+
+					resolve(newAutocompletion.result)
+
+				},
+				onError: (e) => {
+					newAutocompletion.endTime = Date.now()
+					newAutocompletion.status = 'error'
+					reject(e)
+				},
+				voidConfig,
+				abortRef: newAutocompletion.abortRef,
+			})
+
+			// if the request hasnt resolved in TIMEOUT_TIME seconds, reject it
+			setTimeout(() => {
+				if (newAutocompletion.status === 'pending') {
+					reject('Timeout receiving message to LLM.')
+				}
+			}, TIMEOUT_TIME)
+
+
+		})
+
+		// add autocompletion to cache
+		this._autocompletionsOfDocument[docUriStr].set(newAutocompletion.id, newAutocompletion)
+
+		// show autocompletion
+		try {
+			await newAutocompletion.llmPromise
+			console.log('id: ' + newAutocompletion.id)
+
+			const inlineCompletion = toInlineCompletion({ autocompletion: newAutocompletion, prefix, suffix, position })
+			return [inlineCompletion]
+
+		} catch (e) {
+			this._autocompletionsOfDocument[docUriStr].delete(newAutocompletion.id)
+			console.error('Error creating autocompletion (2): ' + e)
+			return []
+		}
+
+	}
+
+
+}

extensions/void/src/extension/DiffProvider.ts

@@ -1,8 +1,9 @@
 import * as vscode from 'vscode';
 import { findDiffs } from './findDiffs';
-import { Diff, DiffArea, BaseDiff, } from './common/shared_types';
-import { readFileContentOfUri } from './common/readFileContentOfUri';
 import { throttle } from 'lodash';
+import { DiffArea, BaseDiff, Diff } from '../common/shared_types';
+import { readFileContentOfUri } from './extensionLib/readFileContentOfUri';
+import { updateWebviewHTML } from './extensionLib/updateWebviewHTML';
 
 
 const THROTTLE_TIME = 100
@@ -31,6 +32,8 @@ export class DiffProvider implements vscode.CodeLensProvider {
 	private _diffareaidPool = 0
 	private _diffidPool = 0
 
+	private _extensionUri: vscode.Uri
+
 	// used internally by vscode
 	private _onDidChangeCodeLenses: vscode.EventEmitter<void> = new vscode.EventEmitter<void>(); // signals a UI refresh on .fire() events
 	public readonly onDidChangeCodeLenses: vscode.Event<void> = this._onDidChangeCodeLenses.event;
@@ -42,9 +45,8 @@ export class DiffProvider implements vscode.CodeLensProvider {
 	}
 
 	// declared by us, registered with vscode.languages.registerCodeLensProvider()
-	constructor() {
-
-		console.log('Creating DisplayChangesProvider')
+	constructor(context: vscode.ExtensionContext) {
+		this._extensionUri = context.extensionUri
 
 		// this acts as a useEffect every time text changes
 		vscode.workspace.onDidChangeTextDocument((e) => {
@@ -163,7 +165,9 @@ export class DiffProvider implements vscode.CodeLensProvider {
 		}
 		const originalFile = this._originalFileOfDocument[docUriStr]
 		if (!originalFile) {
-			console.log('Error: No original file!')
+			if (this._diffAreasOfDocument[docUriStr]?.length > 0) {
+				console.log('Error: More than one diff area exists, but no original file was set.')
+			}
 			return;
 		}
 
@@ -185,7 +189,6 @@ export class DiffProvider implements vscode.CodeLensProvider {
 			// add the diffs to `this._diffsOfDocument[docUriStr]`
 			this.createDiffs(editor.document.uri, diffs, diffArea)
 
-
 			// // print diffs
 			// console.log('!ORIGINAL FILE:', JSON.stringify(originalFile))
 			// console.log('!NEW FILE     :', JSON.stringify(editor.document.getText().replace(/\r\n/g, '\n')))
@@ -210,6 +213,21 @@ export class DiffProvider implements vscode.CodeLensProvider {
 			)
 		);
 
+		// update red highlighting
+		// this._diffsOfDocument[docUriStr]
+		// 	.filter(diff => diff.originalCode !== '')
+		// 	.forEach(diff => {
+		// 		const text = originalFile.split('\n').slice(diff.originalRange.start.line, diff.originalRange.start.line + 1).join('\n')
+		// 		const height = text.split('\n').length
+		// 		const line = diff.range.start.line - 1
+
+		// 		const inset = vscode.window.createWebviewTextEditorInset(editor, line, height);
+		// 		updateWebviewHTML(inset.webview, this._extensionUri, { jsOutLocation: 'dist/webviews/diffline/index.js', cssOutLocation: 'dist/webviews/styles.css' },
+		// 			{ text }
+		// 		)
+
+
+		// 	})
 
 		// for each diffArea, highlight its sweepIndex in dark gray
 		editor.setDecorations(
@@ -234,8 +252,6 @@ export class DiffProvider implements vscode.CodeLensProvider {
 			)
 		)
 
-		// TODO update red highlighting
-		// this._diffsOfDocument[docUriStr].map(diff => diff.deletedCode)
 
 		// update code lenses
 		this._onDidChangeCodeLenses.fire()
@@ -392,7 +408,7 @@ export class DiffProvider implements vscode.CodeLensProvider {
 
 		// figure out where to highlight based on where the AI is in the stream right now, use the last diff in findDiffs to figure that out
 		const diffs = findDiffs(originalDiffAreaCode, newDiffAreaCode)
-		const lastDiff = diffs[diffs.length - 1] ?? null
+		const lastDiff = diffs?.[diffs.length - 1] ?? null
 
 		// these are two different coordinate systems - new and old line number
 		let newFileEndLine: number // get new[0...newStoppingPoint] with line=newStoppingPoint highlighted
@@ -434,6 +450,7 @@ export class DiffProvider implements vscode.CodeLensProvider {
 		const diffareaRange = new vscode.Range(diffArea.startLine, 0, diffArea.endLine, Number.MAX_SAFE_INTEGER)
 		workspaceEdit.replace(editor.document.uri, diffareaRange, newCode)
 		await vscode.workspace.applyEdit(workspaceEdit)
+
 	}, THROTTLE_TIME)
 
 }

extensions/void/src/extension/applyDiffLazily.ts

@@ -1,19 +1,13 @@
 import * as vscode from 'vscode';
-import { AbortRef, OnFinalMessage, OnText, sendLLMMessage } from "./sendLLMMessage"
-import { VoidConfig } from '../sidebar/contextForConfig';
-import { findDiffs } from '../findDiffs';
-import { searchDiffChunkInstructions, writeFileWithDiffInstructions } from './systemPrompts';
-import { throttle } from 'lodash';
-import { readFileContentOfUri } from './readFileContentOfUri';
-import { DiffProvider } from '../DiffProvider';
-import { DiffArea } from './shared_types';
+import { AbortRef, sendLLMMessage } from '../common/sendLLMMessage';
+import { DiffArea } from '../common/shared_types';
+import { writeFileWithDiffInstructions, searchDiffChunkInstructions } from '../common/systemPrompts';
+import { VoidConfig } from '../webviews/common/contextForConfig';
+import { DiffProvider } from './DiffProvider';
+import { readFileContentOfUri } from './extensionLib/readFileContentOfUri';
 
 const LINES_PER_CHUNK = 20 // number of lines to search at a time
 
-// const THRTOTLE_TIME = 100 // minimum time between edits
-// 	throttle(
-// 	THRTOTLE_TIME, { trailing: true }
-// )
 
 type CompetedReturn = { isFinished: true, } | { isFinished?: undefined, }
 const streamChunk = ({ diffProvider, docUri, oldFileStr, completedStr, diffRepr, diffArea, voidConfig, abortRef }: { diffProvider: DiffProvider, docUri: vscode.Uri, oldFileStr: string, completedStr: string, diffRepr: string, voidConfig: VoidConfig, diffArea: DiffArea, abortRef: AbortRef }) => {
@@ -56,7 +50,6 @@ ${completedStr}
 					isAnyChangeSoFar = true
 				}
 
-
 				const isRecentMatchup = false
 				// the final NUM_MATCHUP_TOKENS characters of fullCompletedStr are the same as the final NUM_MATCHUP_TOKENS characters of the last item in the diffs of oldFileStr that had 0 changes
 
@@ -140,7 +133,7 @@ Return \`true\` if ANY part of the chunk should be modified, and \`false\` if it
 
 // lazily applies the diff to the file
 // we chunk the text in the file, and ask an LLM whether it should edit each chunk
-const applyDiffLazily = async ({ docUri, oldFileStr, voidConfig, abortRef, diffRepr, diffProvider, diffArea }: { docUri: vscode.Uri, oldFileStr: string, diffRepr: string, voidConfig: VoidConfig, diffProvider: DiffProvider, diffArea: DiffArea, abortRef: AbortRef }) => {
+export const applyDiffLazily = async ({ docUri, oldFileStr, voidConfig, abortRef, diffRepr, diffProvider, diffArea }: { docUri: vscode.Uri, oldFileStr: string, diffRepr: string, voidConfig: VoidConfig, diffProvider: DiffProvider, diffArea: DiffArea, abortRef: AbortRef }) => {
 
 
 	// stateful variables
@@ -185,7 +178,3 @@ const applyDiffLazily = async ({ docUri, oldFileStr, voidConfig, abortRef, diffR
 
 
 }
-
-
-
-export { applyDiffLazily }

extensions/void/src/extension/ctrlK.ts

@@ -1,35 +1,7 @@
 import * as vscode from 'vscode';
-import { AbortRef, OnFinalMessage, OnText, sendLLMMessage } from "./sendLLMMessage"
-import { VoidConfig } from '../sidebar/contextForConfig';
-import { findDiffs } from '../findDiffs';
-import { searchDiffChunkInstructions, writeFileWithDiffInstructions } from './systemPrompts';
-import { throttle } from 'lodash';
-import { readFileContentOfUri } from './readFileContentOfUri';
-
-type Res<T> = ((value: T) => void)
-
-const THRTOTLE_TIME = 100 // minimum time between edits
-const LINES_PER_CHUNK = 20 // number of lines to search at a time
-
-const applyCtrlLChangesToFile = throttle(
-	({ fileUri, newCurrentLine, oldCurrentLine, fullCompletedStr, oldFileStr, debug }: { fileUri: vscode.Uri, newCurrentLine: number, oldCurrentLine: number, fullCompletedStr: string, oldFileStr: string, debug?: string }) => {
-
-		// write the change to the file
-		const WRITE_TO_FILE = (
-			fullCompletedStr.split('\n').slice(0, newCurrentLine + 1).join('\n')  // newFile[:newCurrentLine+1]
-			+ oldFileStr.split('\n').slice(oldCurrentLine + 1).join('\n')	// oldFile[oldCurrentLine+1:]
-		)
-		const workspaceEdit = new vscode.WorkspaceEdit()
-		workspaceEdit.replace(fileUri, new vscode.Range(0, 0, Number.MAX_SAFE_INTEGER, 0), WRITE_TO_FILE)
-		vscode.workspace.applyEdit(workspaceEdit)
-
-		// highlight the `newCurrentLine` in white
-		// highlight the remaining part of the file in gray
-
-	},
-	THRTOTLE_TIME, { trailing: true }
-)
-
+import { AbortRef, OnFinalMessage, OnText, sendLLMMessage } from "../common/sendLLMMessage"
+import { VoidConfig } from '../webviews/common/contextForConfig';
+import { readFileContentOfUri } from './extensionLib/readFileContentOfUri';
 
 const applyCtrlK = async ({ fileUri, startLine, endLine, instructions, voidConfig, abortRef }: { fileUri: vscode.Uri, startLine: number, endLine: number, instructions: string, voidConfig: VoidConfig, abortRef: AbortRef }) => {
 
@@ -48,24 +20,18 @@ const applyCtrlK = async ({ fileUri, startLine, endLine, instructions, voidConfi
 The user wants to apply the following instructions to the selection:
 ${instructions}
 
-Please rewrite the selection following the user's instructions.
-
-Instructions to follow:
+Instructions:
 1. Follow the user's instructions
 2. You may ONLY CHANGE the selection, and nothing else in the file
 3. Make sure all brackets in the new selection are balanced the same was as in the original selection
-3. Be careful not to duplicate or remove variables, comments, or other syntax by mistake
+4. Be careful not to duplicate or remove variables, comments, or other syntax by mistake
 
-Complete the following:
+Please rewrite the complete the following code, following the instructions.
 \`\`\`
 <PRE>${prefix}</PRE>
 <SUF>${suffix}</SUF>
 <MID>`;
 
-
-	// TODO initialize stream
-
-	// update stream
 	sendLLMMessage({
 		messages: [{ role: 'user', content: promptContent, }],
 		onText: async (tokenStr, completionStr) => {
@@ -98,4 +64,4 @@ Complete the following:
 
 
 
-export { applyCtrlK }
+export { applyCtrlK }

extensions/void/src/extension/extension.ts

@@ -1,30 +1,43 @@
 import * as vscode from 'vscode';
-import { DiffProvider } from './DiffProvider';
-import { DiffArea, ChatThreads, MessageFromSidebar, MessageToSidebar } from './common/shared_types';
-import { SidebarWebviewProvider } from './SidebarWebviewProvider';
-import { v4 as uuidv4 } from 'uuid'
-import { applyDiffLazily } from './common/ctrlL';
-import { getVoidConfig } from './sidebar/contextForConfig';
-import { readFileContentOfUri } from './common/readFileContentOfUri';
-import { AbortRef } from './common/sendLLMMessage';
 
-// this comes from vscode.proposed.editorInsets.d.ts
-declare module 'vscode' {
-	export interface WebviewEditorInset {
-		readonly editor: vscode.TextEditor;
-		readonly line: number;
-		readonly height: number;
-		readonly webview: vscode.Webview;
-		readonly onDidDispose: Event<void>;
-		dispose(): void;
-	}
-	export namespace window {
-		export function createWebviewTextEditorInset(editor: vscode.TextEditor, line: number, height: number, options?: vscode.WebviewOptions): WebviewEditorInset;
-	}
-}
+import { v4 as uuidv4 } from 'uuid'
+import { AbortRef } from '../common/sendLLMMessage';
+import { MessageToSidebar, MessageFromSidebar, DiffArea, ChatThreads } from '../common/shared_types';
+import { getVoidConfigFromPartial } from '../webviews/common/contextForConfig';
+import { applyDiffLazily } from './applyDiffLazily';
+import { DiffProvider } from './DiffProvider';
+import { readFileContentOfUri } from './extensionLib/readFileContentOfUri';
+import { SidebarWebviewProvider } from './providers/SidebarWebviewProvider';
+import { CtrlKWebviewProvider } from './providers/CtrlKWebviewProvider';
+import { AutocompleteProvider } from './AutcompleteProvider';
+import { runTreeSitter } from '../common/LangaugeServer/createJsProgramGraph';
+
+// // this comes from vscode.proposed.editorInsets.d.ts
+// declare module 'vscode' {
+// 	export interface WebviewEditorInset {
+// 		readonly editor: vscode.TextEditor;
+// 		readonly line: number;
+// 		readonly height: number;
+// 		readonly webview: vscode.Webview;
+// 		readonly onDidDispose: Event<void>;
+// 		dispose(): void;
+// 	}
+// 	export namespace window {
+// 		export function createWebviewTextEditorInset(editor: vscode.TextEditor, line: number, height: number, options?: vscode.WebviewOptions): WebviewEditorInset;
+// 	}
+// }
 
 const roundRangeToLines = (selection: vscode.Selection) => {
-	return new vscode.Range(selection.start.line, 0, selection.end.line, Number.MAX_SAFE_INTEGER)
+	let endLine = selection.end.character === 0 ? selection.end.line - 1 : selection.end.line // e.g. if the user triple clicks, it selects column=0, line=line -> column=0, line=line+1
+	return new vscode.Range(selection.start.line, 0, endLine, Number.MAX_SAFE_INTEGER)
+}
+
+const getSelection = (editor: vscode.TextEditor) => {
+	// get the range of the selection and the file the user is in
+	const selectionRange = roundRangeToLines(editor.selection);
+	const selectionStr = editor.document.getText(selectionRange).trim();
+	const filePath = editor.document.uri;
+	return { selectionStr, filePath }
 }
 
 export function activate(context: vscode.ExtensionContext) {
@@ -35,6 +48,8 @@ export function activate(context: vscode.ExtensionContext) {
 		vscode.window.registerWebviewViewProvider(SidebarWebviewProvider.viewId, sidebarWebviewProvider, { webviewOptions: { retainContextWhenHidden: true } })
 	);
 
+	// 1.5
+	const ctrlKWebviewProvider = new CtrlKWebviewProvider(context)
 
 
 	// 2. ctrl+l
@@ -43,30 +58,14 @@ export function activate(context: vscode.ExtensionContext) {
 			const editor = vscode.window.activeTextEditor
 			if (!editor) return
 
-
-			// const inset = vscode.window.createWebviewTextEditorInset(editor, 10, 10, {})
-			// inset.webview.html = `
-			// <html>
-			// 	<body style="pointer-events:none;">Hello World!</body>
-			// </html>
-			// `;
-
-
 			// show the sidebar
 			vscode.commands.executeCommand('workbench.view.extension.voidViewContainer');
 			// vscode.commands.executeCommand('vscode.moveViewToPanel', CustomViewProvider.viewId); // move to aux bar
 
-			// get the range of the selection
-			const selectionRange = roundRangeToLines(editor.selection);
-
-			// get the text the user is selecting
-			const selectionStr = editor.document.getText(selectionRange);
-
-			// get the file the user is in
-			const filePath = editor.document.uri;
+			const { selectionStr, filePath } = getSelection(editor)
 
 			// send message to the webview (Sidebar.tsx)
-			sidebarWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+l', selection: { selectionStr, selectionRange, filePath } } satisfies MessageToSidebar));
+			sidebarWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+l', selection: { selectionStr, filePath } } satisfies MessageToSidebar));
 		})
 	);
 
@@ -77,22 +76,16 @@ export function activate(context: vscode.ExtensionContext) {
 			const editor = vscode.window.activeTextEditor
 			if (!editor) return
 
-			// get the range of the selection
-			const selectionRange = roundRangeToLines(editor.selection);
-
-			// get the text the user is selecting
-			const selectionStr = editor.document.getText(selectionRange);
-
-			// get the file the user is in
-			const filePath = editor.document.uri;
+			const { selectionStr, filePath } = getSelection(editor)
 
 			// send message to the webview (Sidebar.tsx)
-			sidebarWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+k', selection: { selectionStr, selectionRange, filePath } } satisfies MessageToSidebar));
+			// ctrlKWebviewProvider.onPressCtrlK()
+			// sidebarWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+k', selection: { selectionStr, filePath } } satisfies MessageToSidebar));
 		})
 	);
 
 	// 3. Show an approve/reject codelens above each change
-	const diffProvider = new DiffProvider();
+	const diffProvider = new DiffProvider(context);
 	context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', diffProvider));
 
 	// 4. Add approve/reject commands
@@ -121,7 +114,7 @@ export function activate(context: vscode.ExtensionContext) {
 			// Receive messages in the extension from the sidebar webview (messages are sent using `postMessage`)
 			webview.onDidReceiveMessage(async (m: MessageFromSidebar) => {
 
-				const abortApplyRef: AbortRef = { current: null }
+				const abortRef: AbortRef = { current: () => { } }
 
 				if (m.type === 'requestFiles') {
 
@@ -153,9 +146,9 @@ export function activate(context: vscode.ExtensionContext) {
 
 					const docUri = editor.document.uri
 					const fileStr = await readFileContentOfUri(docUri)
-					const voidConfig = getVoidConfig(context.globalState.get('partialVoidConfig') ?? {})
+					const voidConfig = getVoidConfigFromPartial(context.globalState.get('partialVoidConfig') ?? {})
 
-					await applyDiffLazily({ docUri, oldFileStr: fileStr, diffRepr: m.diffRepr, voidConfig, diffProvider, diffArea, abortRef: abortApplyRef })
+					await applyDiffLazily({ docUri, oldFileStr: fileStr, diffRepr: m.diffRepr, voidConfig, diffProvider, diffArea, abortRef: abortRef })
 				}
 				else if (m.type === 'getPartialVoidConfig') {
 					const partialVoidConfig = context.globalState.get('partialVoidConfig') ?? {}
@@ -189,7 +182,18 @@ export function activate(context: vscode.ExtensionContext) {
 		}
 	)
 
+	// 6. Autocomplete
+	const autocompleteProvider = new AutocompleteProvider(context);
+	context.subscriptions.push(vscode.languages.registerInlineCompletionItemProvider('*', autocompleteProvider));
 
+	const voidConfig = getVoidConfigFromPartial(context.globalState.get('partialVoidConfig') ?? {})
+
+	// setupAutocomplete({ voidConfig, abortRef })
+
+	// 7. Language Server
+	console.log('run lsp')
+	let disposable = vscode.commands.registerCommand('typeInspector.inspect', runTreeSitter);
+	context.subscriptions.push(disposable);
 
 
 	// Gets called when user presses ctrl + k (mounts ctrl+k-style codelens)

extensions/void/src/extension/extensionLib/updateWebviewHTML.ts

@@ -0,0 +1,46 @@
+import * as vscode from 'vscode'
+
+function generateNonce() {
+	let text = "";
+	const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	for (let i = 0; i < 32; i++) {
+		text += possible.charAt(Math.floor(Math.random() * possible.length));
+	}
+	return text;
+}
+
+
+// call this when you have access to the webview to set its html
+export const updateWebviewHTML = (webview: vscode.Webview, extensionUri: vscode.Uri, { jsOutLocation, cssOutLocation }: { jsOutLocation: string, cssOutLocation: string }, props?: object) => {
+
+	// 'dist/sidebar/index.js'
+	// 'dist/sidebar/styles.css'
+
+	const scriptUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, jsOutLocation));
+	const stylesUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, cssOutLocation));
+	const rootUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri));
+	const nonce = generateNonce();
+
+	const webviewHTML = `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Custom View</title>
+	<meta http-equiv="Content-Security-Policy" content="img-src vscode-resource: https:; script-src 'nonce-${nonce}'; style-src vscode-resource: 'unsafe-inline' http: https: data:;">
+	<base href="${rootUri}/">
+	<link href="${stylesUri}" rel="stylesheet">
+  </head>
+  <body>
+	<div id="root"${props ? ` data-void-props="${encodeURIComponent(JSON.stringify(props))}"` : ''}></div>
+	<script nonce="${nonce}" src="${scriptUri}"></script>
+  </body>
+  </html>`;
+
+	webview.html = webviewHTML
+
+	webview.options = {
+		enableScripts: true,
+		localResourceRoots: [extensionUri]
+	};
+}

extensions/void/src/extension/findDiffs.ts

@@ -1,7 +1,8 @@
 
 import { Range } from 'vscode';
 import { diffLines, Change } from 'diff';
-import { BaseDiff } from './common/shared_types';
+import { BaseDiff } from '../common/shared_types';
+
 
 
 // class Range {

extensions/void/src/extension/providers/CtrlKWebviewProvider.ts

@@ -0,0 +1,57 @@
+// renders the code from `src/sidebar`
+
+import * as vscode from 'vscode';
+import { updateWebviewHTML as _updateWebviewHTML, updateWebviewHTML } from '../extensionLib/updateWebviewHTML';
+
+// this comes from vscode.proposed.editorInsets.d.ts
+declare module 'vscode' {
+	export interface WebviewEditorInset {
+		readonly editor: vscode.TextEditor;
+		readonly line: number;
+		readonly height: number;
+		readonly webview: vscode.Webview;
+		readonly onDidDispose: Event<void>;
+		dispose(): void;
+	}
+	export namespace window {
+		export function createWebviewTextEditorInset(editor: vscode.TextEditor, line: number, height: number, options?: vscode.WebviewOptions): WebviewEditorInset;
+	}
+}
+
+
+
+export class CtrlKWebviewProvider {
+
+	private readonly _extensionUri: vscode.Uri
+
+	private _idPool = 0
+
+
+
+	constructor(context: vscode.ExtensionContext) {
+		this._extensionUri = context.extensionUri
+	}
+
+	onPressCtrlK() {
+
+		// // TODO if currently selecting a ctrl k element, just focus it and do nothing
+
+
+		// const inset = vscode.window.createWebviewTextEditorInset(editor, line, height);
+
+
+		// const newCtrlKId = this._idPool++
+		// updateWebviewHTML(inset.webview, this._extensionUri, { jsOutLocation: 'dist/webviews/ctrlk/index.js', cssOutLocation: 'dist/webviews/styles.css' },
+		// 	{ id: newCtrlKId }
+		// )
+
+		// ctrlKWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+k', selection: { selectionStr, selectionRange, filePath } } satisfies MessageToSidebar));
+
+
+	}
+
+	onDisposeCtrlK() {
+
+	}
+
+}

extensions/void/src/extension/providers/SidebarWebviewProvider.ts

@@ -0,0 +1,30 @@
+// renders the code from `src/sidebar`
+
+import * as vscode from 'vscode';
+import { updateWebviewHTML as _updateWebviewHTML } from '../extensionLib/updateWebviewHTML';
+
+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
+
+	constructor(context: vscode.ExtensionContext) {
+		// const extensionPath = context.extensionPath // the directory where the extension is installed, might be useful later... was included in webviewProvider code
+		this._extensionUri = context.extensionUri
+
+		let temp_res: typeof this._res | undefined = undefined
+		this.webview = new Promise((res, rej) => { temp_res = res })
+		if (!temp_res) throw new Error("Void sidebar provider: resolver was undefined")
+		this._res = temp_res
+	}
+
+	// called internally by vscode
+	resolveWebviewView(webviewView: vscode.WebviewView, context: vscode.WebviewViewResolveContext, token: vscode.CancellationToken,) {
+		const webview = webviewView.webview;
+		_updateWebviewHTML(webview, this._extensionUri, { jsOutLocation: 'dist/webviews/sidebar/index.js', cssOutLocation: 'dist/webviews/styles.css' })
+		this._res(webview); // resolve webview and _webviewView
+	}
+}

extensions/void/src/sidebar/CtrlK.tsx

@@ -1,20 +0,0 @@
-import React, { useState } from 'react';
-import { useOnVSCodeMessage } from './getVscodeApi';
-
-
-export const CtrlK = () => {
-
-	const [x, sx] = useState('abc')
-
-	useOnVSCodeMessage('ctrl+k', () => {
-		console.log('Ctrl+K pressed')
-		sx('Pressed ctrl+k')
-	})
-
-	return <>
-		<div>
-			{x}
-		</div>
-	</>
-};
-

extensions/void/src/sidebar/index.tsx

@@ -1,66 +0,0 @@
-import * as React from "react"
-import { useEffect } from "react"
-import * as ReactDOM from "react-dom/client"
-import Sidebar from "./Sidebar"
-import { CtrlK } from "./CtrlK"
-import { ThreadsProvider } from "./contextForThreads"
-import { ConfigProvider } from "./contextForConfig"
-import { MessageToSidebar } from "../common/shared_types"
-import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode } from "./getVscodeApi"
-import { identifyUser, initPosthog } from "./metrics/posthog"
-
-if (typeof document === "undefined") {
-	console.log("index.tsx error: document was undefined")
-}
-
-
-const CommonEffects = () => {
-	// initialize posthog
-	useEffect(() => {
-		initPosthog()
-	}, [])
-
-	// when we get the deviceid, identify the user
-	useEffect(() => {
-		getVSCodeAPI().postMessage({ type: 'getDeviceId' });
-		awaitVSCodeResponse('deviceId').then((m => {
-			identifyUser(m.deviceId)
-		}))
-	}, [])
-
-	// Receive messages from the VSCode extension
-	useEffect(() => {
-		const listener = (event: MessageEvent) => {
-			const m = event.data as MessageToSidebar;
-			onMessageFromVSCode(m)
-		}
-		window.addEventListener('message', listener);
-		return () => window.removeEventListener('message', listener)
-	}, [])
-
-	return null
-}
-
-(() => {
-	// mount the sidebar on the id="root" element
-	const rootElement = document.getElementById("root")!
-	console.log("Void root Element:", rootElement)
-
-	const sidebar = (<>
-		<CommonEffects />
-
-		<ThreadsProvider>
-			<ConfigProvider>
-				<Sidebar />
-			</ConfigProvider>
-		</ThreadsProvider>
-
-		<ConfigProvider>
-			<CtrlK />
-		</ConfigProvider>
-
-	</>)
-	const root = ReactDOM.createRoot(rootElement)
-	root.render(sidebar)
-})();
-

extensions/void/src/webviews/common/contextForConfig.tsx

@@ -1,5 +1,6 @@
 import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
 import { awaitVSCodeResponse, getVSCodeAPI, useOnVSCodeMessage } from "./getVscodeApi"
+import { Ollama } from "ollama/browser"
 
 const configEnum = <EnumArr extends readonly string[]>(description: string, defaultVal: EnumArr[number], enumArr: EnumArr) => {
 	return {
@@ -21,15 +22,14 @@ const configString = (description: string, defaultVal: string) => {
 export const configFields = [
 	'anthropic',
 	'openAI',
+	'gemini',
 	'greptile',
 	'ollama',
 	'openRouter',
 	'openAICompatible',
-	'azure'
+	'azure',
 ] as const
 
-
-
 const voidConfigInfo: Record<
 	typeof configFields[number] | 'default', {
 		[prop: string]: {
@@ -50,6 +50,7 @@ const voidConfigInfo: Record<
 			"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",
@@ -117,11 +118,11 @@ const voidConfigInfo: Record<
 			'http://127.0.0.1:11434'
 		),
 		// TODO we should allow user to select model inside Void, but for now we'll just let them handle the Ollama setup on their own
-		// model: configEnum(
-		// 	'Ollama model to use.',
-		// 	'llama3.1',
-		// 	["codegemma", "codegemma:2b", "codegemma:7b", "codellama", "codellama:7b", "codellama:13b", "codellama:34b", "codellama:70b", "codellama:code", "codellama:python", "command-r", "command-r:35b", "command-r-plus", "command-r-plus:104b", "deepseek-coder-v2", "deepseek-coder-v2:16b", "deepseek-coder-v2:236b", "falcon2", "falcon2:11b", "firefunction-v2", "firefunction-v2:70b", "gemma", "gemma:2b", "gemma:7b", "gemma2", "gemma2:2b", "gemma2:9b", "gemma2:27b", "llama2", "llama2:7b", "llama2:13b", "llama2:70b", "llama3", "llama3:8b", "llama3:70b", "llama3-chatqa", "llama3-chatqa:8b", "llama3-chatqa:70b", "llama3-gradient", "llama3-gradient:8b", "llama3-gradient:70b", "llama3.1", "llama3.1:8b", "llama3.1:70b", "llama3.1:405b", "llava", "llava:7b", "llava:13b", "llava:34b", "llava-llama3", "llava-llama3:8b", "llava-phi3", "llava-phi3:3.8b", "mistral", "mistral:7b", "mistral-large", "mistral-large:123b", "mistral-nemo", "mistral-nemo:12b", "mixtral", "mixtral:8x7b", "mixtral:8x22b", "moondream", "moondream:1.8b", "openhermes", "openhermes:v2.5", "phi3", "phi3:3.8b", "phi3:14b", "phi3.5", "phi3.5:3.8b", "qwen", "qwen:7b", "qwen:14b", "qwen:32b", "qwen:72b", "qwen:110b", "qwen2", "qwen2:0.5b", "qwen2:1.5b", "qwen2:7b", "qwen2:72b", "smollm", "smollm:135m", "smollm:360m", "smollm:1.7b"] as const
-		// ),
+		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.2", "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(
@@ -163,6 +164,19 @@ const voidConfigInfo: Record<
 		// 	}
 		// },
 	},
+	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
+		),
+	},
 }
 
 
@@ -185,18 +199,18 @@ export type VoidConfig = {
 
 
 
-export const getVoidConfig = (currentConfig: PartialVoidConfig): VoidConfig => {
+export const getVoidConfigFromPartial = (partialVoidConfig: PartialVoidConfig): VoidConfig => {
 	const config = {} as PartialVoidConfig
 	for (let field of [...configFields, 'default'] as const) {
 		config[field] = {}
 		for (let prop in voidConfigInfo[field]) {
-			config[field][prop] = currentConfig[field]?.[prop] || voidConfigInfo[field][prop].defaultVal
+			config[field][prop] = partialVoidConfig[field]?.[prop]?.trim() || voidConfigInfo[field][prop].defaultVal
 		}
 	}
 	return config as VoidConfig
 }
 
-const defaultVoidConfig: VoidConfig = getVoidConfig({})
+const defaultVoidConfig: VoidConfig = getVoidConfigFromPartial({})
 
 // const [stateRef, setState] = useInstantState(initVal)
 // setState instantly changes the value of stateRef instead of having to wait until the next render
@@ -234,7 +248,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
 		getVSCodeAPI().postMessage({ type: 'getPartialVoidConfig' })
 		awaitVSCodeResponse('partialVoidConfig').then((m) => {
 			setPartialVoidConfig(m.partialVoidConfig)
-			const newFullConfig = getVoidConfig(m.partialVoidConfig)
+			const newFullConfig = getVoidConfigFromPartial(m.partialVoidConfig)
 			setVoidConfig(newFullConfig)
 		})
 	}, [setPartialVoidConfig])
@@ -254,7 +268,7 @@ export function ConfigProvider({ children }: { children: ReactNode }) {
 					}
 				}
 				setPartialVoidConfig(newPartialConfig)
-				const newFullConfig = getVoidConfig(newPartialConfig)
+				const newFullConfig = getVoidConfigFromPartial(newPartialConfig)
 				setVoidConfig(newFullConfig)
 				getVSCodeAPI().postMessage({ type: 'persistPartialVoidConfig', partialVoidConfig: newPartialConfig })
 			}
@@ -272,4 +286,3 @@ export function useVoidConfig(): ConfigValueType {
 	}
 	return context
 }
-

extensions/void/src/webviews/common/contextForProps.tsx

@@ -0,0 +1,36 @@
+import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
+
+const PropsContext = createContext<any>(undefined as unknown as any)
+
+// provider for whatever came in data-void-props
+export function PropsProvider({ children, rootElement }: { children: ReactNode, rootElement: HTMLElement }) {
+
+	const [props, setProps] = useState<object | null>(null)
+
+	// update props when rootElement changes
+	useEffect(() => {
+		let props = rootElement.getAttribute("data-void-props")
+		let propsObj: object | null = null
+		if (props !== null) {
+			propsObj = JSON.parse(decodeURIComponent(props))
+		}
+		setProps(propsObj)
+	}, [rootElement])
+
+	return (
+		<PropsContext.Provider value={props}>
+			{children}
+		</PropsContext.Provider>
+	)
+}
+
+export function useVoidProps<T extends {}>(): T | null {
+	// context is the "value" from above
+	const context: T | null | undefined = useContext<T>(PropsContext)
+	// only undefined if has no provider
+	if (context === undefined) {
+		throw new Error("useVoidProps missing Provider")
+	}
+	return context
+}
+

extensions/void/src/webviews/common/contextForThreads.tsx

@@ -1,5 +1,5 @@
 import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
-import { ChatMessage, ChatThreads } from "../common/shared_types"
+import { ChatMessage, ChatThreads } from "../../common/shared_types"
 import { awaitVSCodeResponse, getVSCodeAPI } from "./getVscodeApi"
 
 

extensions/void/src/webviews/common/getVscodeApi.ts

@@ -1,5 +1,5 @@
 import { useEffect } from "react";
-import { MessageFromSidebar, MessageToSidebar, } from "../common/shared_types";
+import { MessageFromSidebar, MessageToSidebar, } from "../../common/shared_types";
 import { v4 as uuidv4 } from 'uuid';
 
 

extensions/void/src/webviews/common/mount.tsx

@@ -0,0 +1,66 @@
+import React, { useEffect } from "react";
+import * as ReactDOM from "react-dom/client"
+import { MessageToSidebar } from "../../common/shared_types";
+import { getVSCodeAPI, awaitVSCodeResponse, onMessageFromVSCode } from "./getVscodeApi";
+import { initPosthog, identifyUser } from "./posthog";
+import { ThreadsProvider } from "./contextForThreads";
+import { ConfigProvider } from "./contextForConfig";
+import { PropsProvider } from "./contextForProps";
+
+const ListenersAndTracking = () => {
+	// initialize posthog
+	useEffect(() => {
+		initPosthog()
+	}, [])
+
+	// when we get the deviceid, identify the user
+	useEffect(() => {
+		getVSCodeAPI().postMessage({ type: 'getDeviceId' });
+		awaitVSCodeResponse('deviceId').then((m => {
+			identifyUser(m.deviceId)
+		}))
+	}, [])
+
+	// Receive messages from the VSCode extension
+	useEffect(() => {
+		const listener = (event: MessageEvent) => {
+			const m = event.data as MessageToSidebar;
+			onMessageFromVSCode(m)
+		}
+		window.addEventListener('message', listener);
+		return () => window.removeEventListener('message', listener)
+	}, [])
+
+	return null
+}
+
+
+
+
+export const mount = (children: React.ReactNode) => {
+
+	if (typeof document === "undefined") {
+		console.error("index.tsx error: document was undefined")
+		return
+	}
+
+	// mount the sidebar on the id="root" element
+	const rootElement = document.getElementById("root")!
+	// console.log("Void root Element:", rootElement)
+
+	const content = (<>
+		<ListenersAndTracking />
+
+		<PropsProvider rootElement={rootElement}>
+			<ThreadsProvider>
+				<ConfigProvider>
+					{children}
+				</ConfigProvider>
+			</ThreadsProvider>
+		</PropsProvider>
+	</>)
+
+	const root = ReactDOM.createRoot(rootElement)
+	root.render(content);
+
+}

extensions/void/src/webviews/ctrlk/CtrlK.tsx

@@ -0,0 +1,27 @@
+import React, { useState } from 'react';
+import { useOnVSCodeMessage } from '../common/getVscodeApi';
+
+
+export const CtrlK = () => {
+
+	const [x, sx] = useState('abc')
+
+	useOnVSCodeMessage('ctrl+k', () => {
+		console.log('Ctrl+K pressed')
+		sx('Pressed ctrl+k')
+	})
+
+	// const inset = vscode.window.createWebviewTextEditorInset(editor, 10, 10, {})
+	// inset.webview.html = `
+	// <html>
+	// 	<body style="pointer-events:none;">Hello World!</body>
+	// </html>
+	// `;
+
+	return <>
+		<div>
+			{x}
+		</div>
+	</>
+};
+

extensions/void/src/webviews/ctrlk/index.tsx

@@ -0,0 +1,7 @@
+import React from "react"
+import { mount } from "../common/mount"
+import { CtrlK } from "./CtrlK"
+
+// this is the entry point that mounts ctrlk
+mount(<CtrlK />)
+

extensions/void/src/webviews/diffline/DiffLine.tsx

@@ -0,0 +1,29 @@
+import React, { useState } from 'react';
+import { useOnVSCodeMessage } from '../common/getVscodeApi';
+import { useVoidProps } from '../common/contextForProps';
+
+
+type props = {
+	text: string
+}
+
+export const DiffLine = () => {
+
+	const props = useVoidProps<props>()
+
+	console.log('props!', props)
+
+	if (!props) {
+		return null
+	}
+
+	// eslint-disable-next-line react/prop-types
+	const text = props.text
+
+	return <>
+		<div>
+			{text}
+		</div>
+	</>
+};
+

extensions/void/src/webviews/diffline/index.tsx

@@ -0,0 +1,7 @@
+import React from "react"
+import { mount } from "../common/mount"
+import { DiffLine } from "./DiffLine"
+
+// this is the entry point that mounts diffline
+mount(<DiffLine />)
+

extensions/void/src/webviews/sidebar/Sidebar.tsx

@@ -1,11 +1,11 @@
 import React, { useState, useEffect, useRef, useCallback, FormEvent } from "react"
-import { CodeSelection, ChatMessage, MessageToSidebar } from "../common/shared_types"
-import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode, useOnVSCodeMessage } from "./getVscodeApi"
+import { CodeSelection, ChatMessage, MessageToSidebar } from "../../common/shared_types"
+import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode, useOnVSCodeMessage } from "../common/getVscodeApi"
 
 import { SidebarThreadSelector } from "./SidebarThreadSelector";
 import { SidebarChat } from "./SidebarChat";
-import { SidebarSettings } from './SidebarSettings';
-import { identifyUser } from "./metrics/posthog";
+import { SidebarSettings } from "./SidebarSettings";
+import { identifyUser } from "../common/posthog";
 
 
 const Sidebar = () => {

extensions/void/src/webviews/sidebar/SidebarChat.tsx

@@ -4,14 +4,14 @@ import React, { FormEvent, useCallback, useEffect, useRef, useState } from "reac
 import { marked } from 'marked';
 import MarkdownRender from "./markdown/MarkdownRender";
 import BlockCode from "./markdown/BlockCode";
-import { File, ChatMessage, CodeSelection } from "../common/shared_types";
+import { File, ChatMessage, CodeSelection } from "../../common/shared_types";
 import * as vscode from 'vscode'
-import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode, useOnVSCodeMessage } from "./getVscodeApi";
-import { useThreads } from "./contextForThreads";
-import { sendLLMMessage } from "../common/sendLLMMessage";
-import { useVoidConfig } from "./contextForConfig";
-import { generateDiffInstructions } from "../common/systemPrompts";
-import { captureEvent } from "./metrics/posthog";
+import { awaitVSCodeResponse, getVSCodeAPI, onMessageFromVSCode, useOnVSCodeMessage } from "../common/getVscodeApi";
+import { useThreads } from "../common/contextForThreads";
+import { sendLLMMessage } from "../../common/sendLLMMessage";
+import { useVoidConfig } from "../common/contextForConfig";
+import { captureEvent } from "../common/posthog";
+import { generateDiffInstructions } from "../../common/systemPrompts";
 
 
 
@@ -156,7 +156,7 @@ export const SidebarChat = ({ chatInputRef }: { chatInputRef: React.RefObject<HT
 	// state of chat
 	const [messageStream, setMessageStream] = useState('')
 	const [isLoading, setIsLoading] = useState(false)
-	const abortFnRef = useRef<(() => void) | null>(null)
+	const abortFnRef = useRef<(() => void)>(() => { })
 
 	const [latestError, setLatestError] = useState('')
 

extensions/void/src/webviews/sidebar/SidebarSettings.tsx

@@ -1,5 +1,5 @@
 import React, { useState } from "react";
-import { configFields, useVoidConfig, VoidConfigField } from "./contextForConfig";
+import { configFields, useVoidConfig, VoidConfigField } from "../common/contextForConfig";
 
 
 const SettingOfFieldAndParam = ({ field, param }: { field: VoidConfigField, param: string }) => {

extensions/void/src/webviews/sidebar/SidebarThreadSelector.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { ThreadsProvider, useThreads } from "./contextForThreads";
+import { ThreadsProvider, useThreads } from "../common/contextForThreads";
 
 
 const truncate = (s: string) => {

extensions/void/src/webviews/sidebar/index.tsx

@@ -0,0 +1,7 @@
+import React from "react"
+import Sidebar from "./Sidebar"
+import { mount } from "../common/mount"
+
+// this is the entry point that mounts the sidebar
+mount(<Sidebar />)
+

extensions/void/src/webviews/sidebar/markdown/MarkdownRender.tsx

@@ -1,7 +1,7 @@
 import React, { JSX, useCallback, useEffect, useState } from "react"
 import { marked, MarkedToken, Token, TokensList } from "marked"
 import BlockCode from "./BlockCode"
-import { getVSCodeAPI } from "../getVscodeApi"
+import { getVSCodeAPI } from "../../common/getVscodeApi"
 
 
 enum CopyButtonState {

extensions/void/src/webviews/styles.css

@@ -1,3 +1,5 @@
+/* all the styles are shared right now between all webviews */
+
 @tailwind base;
 @tailwind components;
 @tailwind utilities;

extensions/void/tailwind.config.js

@@ -2,7 +2,7 @@
 
 // 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}"],
+	content: ["./src/webviews/**/*.{html,js,ts,jsx,tsx}"],
 	theme: {
 		extend: {
 			colors: {

extensions/void/tsconfig.json

@@ -1,7 +1,7 @@
 {
 	"include": [
 		"src/**/*"
-	],
+, "../../src/vs/workbench/contrib/welcomeGettingStarted/common/AutcompleteProvider.tsx"	],
 	"exclude": [
 		"node_modules"
 	],
@@ -27,4 +27,4 @@
 		// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
 		// "noUnusedParameters": true,  /* Report errors on unused parameters. */
 	}
-}
+}