Max tokens is optional + other config updates - Fixes #128

Doc : Build command fix

CONTRIBUTING.md

@@ -1,17 +1,16 @@
 # 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
+
 Here's how you can start contributing to the Void extension. This is where you should get started if you're new.
 
 1. Clone the repository:
@@ -20,11 +19,7 @@ Here's how you can start contributing to the Void extension. This is where you s
 git clone https://github.com/voideditor/void
 ```
 
-2. Open the folder `/extensions/void` in VS Code (open it in a new workspace, *don't* just cd into it):
-
-```
-open /extensions/void
-```
+2. Open the folder `/extensions/void` in VSCode (open it in a new workspace, _don't_ just cd into it).
 
 3. Install dependencies:
 
@@ -32,27 +27,51 @@ open /extensions/void
 npm install
 ```
 
-4. Build the project. We created this build command so that we could run React in vscode - it converts `sidebar/index.tsx` into a CSS/JS bundle in `dist/`.
+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 VS Code with the extension enabled. If this does not work, you can press <kbd>Ctrl+Shift+P</kbd>, select "Debug: Start Debugging", and select "VS Code Extension Development".
-
-If you would like to use AI features, you need to provide an API key. You can do that by going to Settings (Ctrl+,) typing in "void", and adding the API key you want to use (eg. the `"Anthropic Api Key"` environment variable). The "Which API" environment variable controls the provider and defaults to "anthropic".
-
-Now that you're set up, feel free to check out our [Issues](https://github.com/voideditor/void/issues) page!
+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
 
-Beyond the extension, we very occasionally edit the IDE when we need to access more functionality. If you want to work on the full IDE, please follow the steps below, or see VS Code's full [how to contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page.
+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.
 
-Before starting, make sure you've built the extension (by running `cd .\extensions\void\` and `npm run build`). Also make sure you have Python on your system.
+<!-- TODO say whether you can build each distribution on any Operating System, or if you need to build Windows on Windows, etc -->
 
-Make sure you're on the correct NodeJS version as per `.nvmrc`.
+### 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.
+
+Find the box for Visual Studio 2022 (or VS Build Tools) and click Install/Modify.
+
+Under Workloads, select "Desktop development with C++" and "Node.js build tools".
+
+Under Individual components, select every item under:
+
+- `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/Modify.
+
+### 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 the Void extension (or just run `cd ./extensions/void && npm install && npm run build && npm run compile && cd ../..`).
+
+First, open `void/` in VSCode. Then:
 
 1. Install all dependencies.
 
@@ -60,91 +79,82 @@ Make sure you're on the correct NodeJS version as per `.nvmrc`.
 npm install
 ```
 
-2. In VS Code, press <kbd>Ctrl+Shift+B</kbd> to start the build process - this can take some time. If you're not using VS Code, run `npm run watch` instead.
+2. Press <kbd>Ctrl+Shift+B</kbd>, or if you prefer using the terminal run `npm run watch`.
 
-3. Run `./scripts/code.sh` in your terminal.
+This can take ~5 min.
 
-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".
+If you ran <kbd>Ctrl+Shift+B</kbd>, the build is done when you see two check marks.
 
-To bundle the IDE, run `npm run gulp vscode-darwin-arm64`. Here are the full options: `vscode-{win32-ia32 | win32-x64 | darwin-x64 | darwin-arm64 | linux-ia32 | linux-x64 | linux-arm}(-min)`
+If you ran `npm run watch`, the build is done when you see something like this:
 
-If you're on Windows, we recommend running the project inside a dev container. VSCode should prompt you to do this automatically.
+```
+[watch-extensions] [00:37:39] Finished compilation extensions with 0 errors after 19303 ms
+[watch-client    ] [00:38:06] Finished compilation with 0 errors after 46248 ms
+[watch-client    ] [00:38:07] Starting compilation...
+[watch-client    ] [00:38:07] Finished compilation with 0 errors after 5 ms
+```
+
+<!-- 3. Press <kbd>Ctrl+Shift+B</kbd> to start the build process. -->
+
+1. In a new terminal, run `./scripts/code.sh` (Mac/Linux) or `/.scripts/code.bat` (Windows). This should open up the built IDE!
+
+To see new changes without restarting the build, press <kbd>Ctrl+Shift+P</kbd> and run "Reload Window" inside the new window.
 
 Now that you're set up, feel free to check out our [Issues](https://github.com/voideditor/void/issues) page!
 
+
+### Common Fixes
+
+- Make sure you have the same NodeJS version as `.nvmrc`.
+
+- If you see `[ERROR] Cannot start service: Host version "0.23.1" does not match binary version "0.23.0"`, run `npm i -D esbuild@0.23.0` or do a clean install of your npm dependencies.
+
+
+## Bundling
+
+To bundle the IDE into an executable, run `npm run gulp vscode-darwin-arm64`.
+
+Here are the full options: `vscode-{win32-ia32 | win32-x64 | darwin-x64 | darwin-arm64 | linux-ia32 | linux-x64 | linux-arm}(-min)`
+
+
 ## Roadmap
 
 Here are the most important topics on our Roadmap. More ⭐'s = more important.
 
-## ⭐⭐⭐ Improve diffs.
-
-We define a "diff" as a single green/red pair that denotes a change. Here are improvements to make:
-
-1. Show deletion (-) diffs. Right now we're only showing insertion (+) diffs. Diffs currently work by highlighting all of the new code in green with a simple text decoration. Instead, we would like to use code from VS Code's native diffEditor to show the diffs ("inline" mode). We could alternatively keep what we have and add red zones of the deleted code to indicate a deletion diff (-).
-
-2. Fix bugginess when the user presses "Accept" or "Reject" on a diff. One issue is that when a diff is accepted/rejected all of the diffs below should be updated (because they are now on different line numbers). There are other miscellaneous issues too.
-
-3. Make diff highlighting dynamic. Right now when the user edits text, all of the diffs and their highlights are cleared. Instead, we should update the highlighting of the diff. Each diff lives on a range of lines, and all changes inside that range or intersecting with it should update its highlighting.
-
-## ⭐⭐⭐ Build Cursor-style quick edits (ctrl+k).
-
-When the user presses ctrl+k, an input box should appear inline with the code that they were selecting. This is somewhat difficult to do because an extension alone cannot do this, and it requires creating a new component in the IDE. We think you can modify vscode's built-in "codelens" or "zone widget" components, but we are open to alternatives.
+These sometimes get outdated - 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.
 
-## ⭐⭐⭐ Improve Ctrl+L backend.
+## ⭐⭐⭐ Build Cursor-style quick edits (Ctrl+K).
 
-Right now, the model outputs entire files. Instead, we should change the prompt so that the model outputs partial changes like `// ... rest of file`. When the user clicks the "Apply" button, the model should rewrite the file and apply the partial changes in the correct locations.
-
-## ⭐⭐ Integrate with Ollama.
-
-We have an Ollama integration coded up in the extension, but it breaks. This is because Ollama has Node.js dependencies like 'path' and 'os' which cannot run in extensions (extensions have to be able to run in the browser). To fix this, we need to migrate Void's extension so that it runs natively into the VS Code editor so that we can access Node.js.
+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.
 
-Feel free to build AI features beyond the standard Cursor ones. For example, creating better code search, or supporting AI agents that can edit across files and make multiple LLM calls.
+Examples: creating better code search, or supporting AI agents that can edit across files and make multiple LLM calls.
 
 Eventually, we want to build a convenient API for creating AI tools. The API will provide methods for creating the UI (showing an autocomplete suggestion, or creating a new diff), detecting event changes (like `onKeystroke` or `onFileOpen`), and modifying the user's file-system (storing indexes associated with each file), making it much easier to make your own AI plugin. We plan on building these features further along in timeline, but we wanted to list them for completeness.
 
 ## ⭐ One-stars.
 
-⭐ When user presses ctrl+L it should clear the sidebar's state.
-
-⭐ Let the user accept / reject all Diffs in an entire file via the sidebar.
-
-⭐ Allow the user to make multiple selections of code or files at once.
-
-⭐ Allow user to X out of their current selection.
+⭐ 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). 
-
-- Your title should clearly describe the change you made.
-
-- Add tags to help us stay organized!
-
-- Please don't open a new Issue for your PR. Just submit the PR.
-
-- Avoid refactoring and making feature changes in the same PR. 
-
-- Write good code. For example, a common mistake when people edit Void's config is to hard-code a default value like `'claude-3.5'` in 2+ separate places. Please follow best practices or describe your thought process if you had to compromise.
+Please submit a pull request once you've made a change. You don't need to submit an issue.
 
 # Relevant files
 
 We keep track of all the files we've changed with Void so it's easy to rebase:
 
-
 - README.md
 - CONTRIBUTING.md
 - VOID_USEFUL_LINKS.md
@@ -153,12 +163,19 @@ We keep track of all the files we've changed with Void so it's easy to rebase:
 
 - src/vs/workbench/api/common/{extHost.api.impl.ts | extHostApiCommands.ts}
 - src/vs/workbench/workbench.common.main.ts
-- src/vs/workbench/contrib/void
-- extensions/void
+- src/vs/workbench/contrib/void/\*
+- extensions/void/\*
 
-- .github/
-- .vscode/settings
+- .github/\*
+- .vscode/settings/\*
 - .eslintrc.json
 - build/hygiene.js
 - build/lib/i18n.resources.json
 - build/npm/dirs.js
+
+- vscode.proposed.editorInsets.d.ts - not modified, but code copied
+
+
+## References
+
+For some useful links we've compiled on VSCode, see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).

README.md

@@ -1,7 +1,7 @@
 # Welcome to Void.
 
 
-Void is the open-source Cursor alternative. 
+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.
 
@@ -19,4 +19,4 @@ For some useful links we've compiled see [`VOID_USEFUL_LINKS.md`](https://github
 
 
 ## Support
-Feel free to reach out in our [Discord](https://discord.gg/PspNkKG5wt) or contact us via email.
+Feel free to reach out in our [Discord](https://discord.gg/RSNjgaugJs) or contact us via email.

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,59 @@
+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',
+	})
+
+	// convert tailwind to css
+	await convertTailwindToCSS({
+		from: 'src/webviews/styles.css',
+		to: 'dist/webviews/styles.css',
+	})
+
+})()
+

extensions/void/package.json

@@ -5,13 +5,13 @@
   "description": "",
   "version": "0.0.1",
   "engines": {
-    "vscode": "^1.89.0"
+    "vscode": "^1.92.0"
   },
   "categories": [
     "Other"
   ],
   "activationEvents": [],
-  "main": "./out/extension.js",
+  "main": "./out/extension/extension.js",
   "contributes": {
     "configuration": {
       "title": "Void",
@@ -24,7 +24,7 @@
       },
       {
         "command": "void.ctrl+k",
-        "title": "Show Selection Lens"
+        "title": "Make Inline Edit"
       },
       {
         "command": "void.acceptDiff",
@@ -102,20 +102,27 @@
   },
   "scripts": {
     "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",
+    "@monaco-editor/react": "^4.6.0",
+    "@rrweb/types": "^2.0.0-alpha.17",
     "@types/diff": "^5.2.2",
     "@types/diff-match-patch": "^1.0.36",
     "@types/jest": "^29.5.12",
+    "@types/lodash": "^4.17.12",
     "@types/mocha": "^10.0.8",
     "@types/node": "^22.5.1",
     "@types/react": "^18.3.4",
     "@types/react-dom": "^18.3.0",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "@types/uuid": "^10.0.0",
     "@types/vscode": "1.92.0",
     "@typescript-eslint/eslint-plugin": "^8.3.0",
     "@typescript-eslint/parser": "^8.3.0",
@@ -128,21 +135,21 @@
     "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",
     "postcss": "^8.4.41",
+    "posthog-js": "^1.176.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-markdown": "^9.0.1",
     "react-syntax-highlighter": "^15.6.1",
     "rimraf": "^6.0.1",
+    "rrweb-snapshot": "^2.0.0-alpha.4",
     "tailwindcss": "^3.4.10",
     "typescript": "5.5.4",
     "typescript-eslint": "^8.3.0",
     "uuid": "^10.0.0"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.27.1",
-    "openai": "^4.57.0"
   }
 }

extensions/void/src/DisplayChangesProvider.ts

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

extensions/void/src/SidebarWebviewProvider.ts

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

extensions/void/src/common/ctrlK.ts

@@ -0,0 +1,100 @@
+import * as vscode from 'vscode';
+import { AbortRef, OnFinalMessage, OnText, sendLLMMessage } from "./sendLLMMessage"
+import { VoidConfig } from '../webviews/common/contextForConfig';
+import { searchDiffChunkInstructions, writeFileWithDiffInstructions } from './systemPrompts';
+import { throttle } from 'lodash';
+import { readFileContentOfUri } from '../extension/extensionLib/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 }
+)
+
+
+const applyCtrlK = async ({ fileUri, startLine, endLine, instructions, voidConfig, abortRef }: { fileUri: vscode.Uri, startLine: number, endLine: number, instructions: string, voidConfig: VoidConfig, abortRef: AbortRef }) => {
+
+	const fileStr = await readFileContentOfUri(fileUri)
+	const fileLines = fileStr.split('\n')
+
+	const prefix = fileLines.slice(startLine).join('\n')
+	const suffix = fileLines.slice(endLine + 1).join('\n')
+	const selection = fileLines.slice(startLine, endLine + 1).join('\n')
+
+	const promptContent = `Here is the user's original selection:
+\`\`\`
+<MID>${selection}</MID>
+\`\`\`
+
+The user wants to apply the following instructions to the selection:
+${instructions}
+
+Please rewrite the selection following the user's instructions.
+
+Instructions to follow:
+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
+
+Complete the following:
+\`\`\`
+<PRE>${prefix}</PRE>
+<SUF>${suffix}</SUF>
+<MID>`;
+
+
+	// TODO initialize stream
+
+	// update stream
+	sendLLMMessage({
+		messages: [{ role: 'user', content: promptContent, }],
+		onText: async (tokenStr, completionStr) => {
+			// TODO update stream
+
+
+			// apply the changes
+			const newCode = `${prefix}\n${completionStr}\n${suffix}`
+			const workspaceEdit = new vscode.WorkspaceEdit()
+			workspaceEdit.replace(fileUri, new vscode.Range(0, 0, Number.MAX_SAFE_INTEGER, 0), newCode)
+			vscode.workspace.applyEdit(workspaceEdit)
+		},
+		onFinalMessage: (completionStr) => {
+			// TODO end stream
+
+			// apply the changes
+			const newCode = `${prefix}\n${completionStr}\n${suffix}`
+			const workspaceEdit = new vscode.WorkspaceEdit()
+			workspaceEdit.replace(fileUri, new vscode.Range(0, 0, Number.MAX_SAFE_INTEGER, 0), newCode)
+			vscode.workspace.applyEdit(workspaceEdit)
+		},
+		onError: (e) => {
+			console.error('Error rewriting file with diff', e);
+		},
+		voidConfig,
+		abortRef,
+	})
+
+}
+
+
+
+export { applyCtrlK }

extensions/void/src/common/sendLLMMessage.ts

@@ -1,52 +1,71 @@
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import { Ollama } from 'ollama/browser'
-import { VoidConfig } from '../sidebar/contextForConfig';
+import { VoidConfig } from '../webviews/common/contextForConfig'
 
+export type AbortRef = { current: (() => void) | null }
 
+export type OnText = (newText: string, fullText: string) => void
 
+export type OnFinalMessage = (input: string) => void
 
-type OnText = (newText: string, fullText: string) => void
+export type LLMMessageAnthropic = {
+	role: 'user' | 'assistant',
+	content: string,
+}
 
 export type LLMMessage = {
-	role: 'user' | 'assistant',
-	content: string
+	role: 'system' | 'user' | 'assistant',
+	content: string,
 }
 
 type SendLLMMessageFnTypeInternal = (params: {
 	messages: LLMMessage[],
 	onText: OnText,
-	onFinalMessage: (input: string) => void,
+	onFinalMessage: OnFinalMessage,
 	onError: (error: string) => void,
 	voidConfig: VoidConfig,
-})
-	=> {
-		abort: () => void
-	}
+	abortRef: AbortRef,
+}) => void
 
 type SendLLMMessageFnTypeExternal = (params: {
 	messages: LLMMessage[],
 	onText: OnText,
-	onFinalMessage: (input: string) => void,
+	onFinalMessage: (fullText: string) => void,
 	onError: (error: string) => void,
 	voidConfig: VoidConfig | null,
-})
-	=> {
-		abort: () => void
-	}
+	abortRef: AbortRef,
+}) => void
 
 
 
+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 }) => {
 
 	const anthropic = new Anthropic({ apiKey: voidConfig.anthropic.apikey, dangerouslyAllowBrowser: true }); // defaults to process.env["ANTHROPIC_API_KEY"]
 
+	// find system messages and concatenate them
+	const systemMessage = messages
+		.filter(msg => msg.role === 'system')
+		.map(msg => msg.content)
+		.join('\n');
+
+	// remove system messages for Anthropic
+	const anthropicMessages = messages.filter(msg => msg.role !== 'system') as LLMMessageAnthropic[]
+
 	const stream = anthropic.messages.stream({
+		system: systemMessage,
+		messages: anthropicMessages,
 		model: voidConfig.anthropic.model,
-		max_tokens: parseInt(voidConfig.anthropic.maxTokens),
-		messages: messages,
+		max_tokens: parseInt(voidConfig.default.maxTokens),
 	});
 
 	let did_abort = false
@@ -77,34 +96,35 @@ const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFi
 
 	// if abort is called, onFinalMessage is NOT called, and no later onTexts are called either
 	const abort = () => {
-		// stream.controller.abort() // TODO need to test this to make sure it works, it might throw an error
 		did_abort = true
+		stream.controller.abort() // TODO need to test this to make sure it works, it might throw an error
 	}
 
 	return { abort }
-
 };
 
 
 
 
 // OpenAI, OpenRouter, OpenAICompatible
-const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
+const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ 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
-	let abort: () => void = () => {
+	abortRef.current = () => {
 		didAbort = true;
 	};
 
 	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, }
+		options = { model: voidConfig.openAI.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
 	}
 	else if (voidConfig.default.whichApi === 'openRouter') {
 		openai = new OpenAI({
@@ -114,11 +134,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, }
+		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, }
+		options = { model: voidConfig.openAICompatible.model, messages: messages, stream: true, max_completion_tokens: maxTokens }
 	}
 	else {
 		console.error(`sendOpenAIMsg: invalid whichApi: ${voidConfig.default.whichApi}`)
@@ -128,7 +148,7 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 	openai.chat.completions
 		.create(options)
 		.then(async response => {
-			abort = () => {
+			abortRef.current = () => {
 				// response.controller.abort()
 				didAbort = true;
 			}
@@ -156,18 +176,17 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 			}
 		})
 
-	return { abort };
 };
 
 
 // Ollama
-export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
+export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ 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
-	let abort = () => {
+	abortRef.current = () => {
 		didAbort = true;
 	};
 
@@ -177,10 +196,11 @@ export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText,
 		model: voidConfig.ollama.model,
 		messages: messages,
 		stream: true,
+		options: { num_predict: parseInt(voidConfig.default.maxTokens) } // this is max_tokens
 	})
 		.then(async stream => {
-			abort = () => {
-				// ollama.abort()
+			abortRef.current = () => {
+				// stream.abort()
 				didAbort = true
 			}
 			// iterate through the stream
@@ -198,7 +218,6 @@ export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText,
 			onError(error)
 		})
 
-	return { abort };
 };
 
 
@@ -207,13 +226,15 @@ export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText,
 // https://docs.greptile.com/api-reference/query
 // https://docs.greptile.com/quickstart#sample-response-streamed
 
-const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
+const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ 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
-	let abort: () => void = () => { didAbort = true }
+	abortRef.current = () => {
+		didAbort = true
+	}
 
 
 	fetch('https://api.greptile.com/v2/query', {
@@ -226,7 +247,7 @@ const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFin
 		body: JSON.stringify({
 			messages,
 			stream: true,
-			repositories: [voidConfig.greptile.repoinfo]
+			repositories: [voidConfig.greptile.repoinfo],
 		}),
 	})
 		// this is {message}\n{message}\n{message}...\n
@@ -268,28 +289,28 @@ const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFin
 			onError(e)
 		});
 
-	return { abort }
-
 }
 
 
 
-export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText, onFinalMessage, onError, voidConfig }) => {
-	if (!voidConfig) return { abort: () => { } }
+export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText, onFinalMessage, onError, voidConfig, abortRef }) => {
+	if (!voidConfig) return;
+
+	// trim message content (Anthropic and other providers give an error if there is trailing whitespace)
+	messages = messages.map(m => ({ ...m, content: m.content.trim() }))
 
 	switch (voidConfig.default.whichApi) {
 		case 'anthropic':
-			return sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig });
+			return sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'openAI':
 		case 'openRouter':
 		case 'openAICompatible':
-			return sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig });
+			return sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'ollama':
-			return sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig });
+			return sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'greptile':
-			return sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig });
+			return sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		default:
 			onError(`Error: whichApi was ${voidConfig.default.whichApi}, which is not recognized!`)
-			return { abort: () => { } }
 	}
 }

extensions/void/src/common/shared_types.ts

@@ -1,6 +1,6 @@
 
 import * as vscode from 'vscode';
-import { PartialVoidConfig } from './sidebar/contextForConfig';
+import { PartialVoidConfig } from '../webviews/common/contextForConfig'
 
 
 
@@ -10,26 +10,23 @@ type CodeSelection = { selectionStr: string, selectionRange: vscode.Range, fileP
 type File = { filepath: vscode.Uri, content: string }
 
 // an area that is currently being diffed
-type BaseDiffArea = {
-	// use `startLine` and `endLine` instead of `range` for mutibility
-	// bounds are relative to the file, inclusive
-	startLine: number;
-	endLine: number;
+type DiffArea = {
+	diffareaid: number,
+	startLine: number,
+	endLine: number,
 	originalStartLine: number,
 	originalEndLine: number,
-	originalCode: string, // the original chunk of code (not necessarily the whole file)
-	// `newCode: string,` is not included because it is the code in the actual file, `document.text()[startline: endLine + 1]`
+	sweepIndex: number | null // null iff not sweeping
 }
 
-type DiffArea = BaseDiffArea & { diffareaid: number }
-
 // the return type of diff creator
 type BaseDiff = {
-	code: string; // representation of the diff in text
-	deletedRange: vscode.Range; // relative to the file, inclusive
-	insertedRange: vscode.Range;
-	deletedCode: string;
-	insertedCode: string;
+	type: 'edit' | 'insertion' | 'deletion';
+	// repr: string; // representation of the diff in text
+	originalRange: vscode.Range;
+	originalCode: string;
+	range: vscode.Range;
+	code: string;
 }
 
 // each diff on the user's screen
@@ -41,29 +38,33 @@ type Diff = {
 // editor -> sidebar
 type MessageToSidebar = (
 	| { type: 'ctrl+l', selection: CodeSelection } // user presses ctrl+l in the editor
+	| { type: 'ctrl+k', selection: CodeSelection }
 	| { type: 'files', files: { filepath: vscode.Uri, content: string }[] }
 	| { type: 'partialVoidConfig', partialVoidConfig: PartialVoidConfig }
 	| { type: 'allThreads', threads: ChatThreads }
 	| { type: 'startNewThread' }
 	| { type: 'toggleThreadSelector' }
 	| { type: 'toggleSettings' }
+	| { type: 'deviceId', deviceId: string }
 )
 
 // sidebar -> editor
 type MessageFromSidebar = (
-	| { type: 'applyChanges', code: string } // user clicks "apply" in the sidebar
+	| { type: 'applyChanges', diffRepr: string } // user clicks "apply" in the sidebar
 	| { type: 'requestFiles', filepaths: vscode.Uri[] }
 	| { type: 'getPartialVoidConfig' }
 	| { type: 'persistPartialVoidConfig', partialVoidConfig: PartialVoidConfig }
 	| { type: 'getAllThreads' }
 	| { type: 'persistThread', thread: ChatThreads[string] }
+	| { type: 'getDeviceId' }
 )
 
 
 type ChatThreads = {
 	[id: string]: {
 		id: string; // store the id here too
-		createdAt: string;
+		createdAt: string; // ISO string
+		lastModified: string; // ISO string
 		messages: ChatMessage[];
 	}
 }
@@ -79,12 +80,17 @@ type ChatMessage =
 	| {
 		role: "assistant";
 		content: string; // content received from LLM
-		displayContent: string; // content displayed to user (this is the same as content for now)
+		displayContent: string | undefined; // content displayed to user (this is the same as content for now)
+	}
+	| {
+		role: "system";
+		content: string;
+		displayContent?: undefined;
 	}
 
 export {
-	BaseDiff, BaseDiffArea,
-	Diff, DiffArea,
+	BaseDiff, Diff,
+	DiffArea,
 	CodeSelection,
 	File,
 	MessageFromSidebar,

extensions/void/src/common/systemPrompts.ts

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

extensions/void/src/extension.ts

@@ -1,61 +1,111 @@
 import * as vscode from 'vscode';
-import { DisplayChangesProvider } from './DisplayChangesProvider';
-import { BaseDiffArea, ChatThreads, MessageFromSidebar, MessageToSidebar } from './shared_types';
-import { SidebarWebviewProvider } from './SidebarWebviewProvider';
 
-const readFileContentOfUri = async (uri: vscode.Uri) => {
-	return Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf8')
-		.replace(/\r\n/g, '\n') // replace windows \r\n with \n
+import { DiffArea, ChatThreads, MessageFromSidebar, MessageToSidebar } from './common/shared_types';
+import { v4 as uuidv4 } from 'uuid'
+import { AbortRef } from './common/sendLLMMessage';
+import { DiffProvider } from './extension/DiffProvider';
+import { SidebarWebviewProvider } from './extension/providers/SidebarWebviewProvider';
+import { getVoidConfigFromPartial } from './webviews/common/contextForConfig';
+import { applyDiffLazily } from './extension/ctrlL';
+import { readFileContentOfUri } from './extension/extensionLib/readFileContentOfUri';
+
+// 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)
 }
 
 export function activate(context: vscode.ExtensionContext) {
 
 	// 1. Mount the chat sidebar
-	const webviewProvider = new SidebarWebviewProvider(context);
+	const sidebarWebviewProvider = new SidebarWebviewProvider(context);
 	context.subscriptions.push(
-		vscode.window.registerWebviewViewProvider(SidebarWebviewProvider.viewId, webviewProvider, { webviewOptions: { retainContextWhenHidden: true } })
+		vscode.window.registerWebviewViewProvider(SidebarWebviewProvider.viewId, sidebarWebviewProvider, { webviewOptions: { retainContextWhenHidden: true } })
 	);
 
-	// 2. Activate the sidebar on ctrl+l
+
+
+	// 2. ctrl+l
 	context.subscriptions.push(
 		vscode.commands.registerCommand('void.ctrl+l', () => {
-
 			const editor = vscode.window.activeTextEditor
-			if (!editor)
-				return
+			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 text the user is selecting
-			const selectionStr = editor.document.getText(editor.selection);
-
 			// get the range of the selection
-			const selectionRange = editor.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;
 
 			// send message to the webview (Sidebar.tsx)
-			webviewProvider.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, selectionRange, filePath } } satisfies MessageToSidebar));
+		})
+	);
+
+	// 2.5: ctrl+k
+	context.subscriptions.push(
+		vscode.commands.registerCommand('void.ctrl+k', () => {
+			console.log('CTRLK PRESSED')
+			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;
+
+			// send message to the webview (Sidebar.tsx)
+			sidebarWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+k', selection: { selectionStr, selectionRange, filePath } } satisfies MessageToSidebar));
 		})
 	);
 
 	// 3. Show an approve/reject codelens above each change
-	const displayChangesProvider = new DisplayChangesProvider();
-	context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', displayChangesProvider));
+	const diffProvider = new DiffProvider();
+	context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', diffProvider));
 
 	// 4. Add approve/reject commands
 	context.subscriptions.push(vscode.commands.registerCommand('void.acceptDiff', async (params) => {
-		displayChangesProvider.acceptDiff(params)
+		diffProvider.acceptDiff(params)
 	}));
 	context.subscriptions.push(vscode.commands.registerCommand('void.rejectDiff', async (params) => {
-		displayChangesProvider.rejectDiff(params)
+		diffProvider.rejectDiff(params)
 	}));
 
 	// 5. Receive messages from sidebar
-	webviewProvider.webview.then(
+	sidebarWebviewProvider.webview.then(
 		webview => {
 
 			// top navigation bar commands
@@ -72,6 +122,8 @@ 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 }
+
 				if (m.type === 'requestFiles') {
 
 					// get contents of all file paths
@@ -82,38 +134,29 @@ export function activate(context: vscode.ExtensionContext) {
 					// send contents to webview
 					webview.postMessage({ type: 'files', files, } satisfies MessageToSidebar)
 
-				} else if (m.type === 'applyChanges') {
+				}
+				else if (m.type === 'applyChanges') {
 
 					const editor = vscode.window.activeTextEditor
 					if (!editor) {
 						vscode.window.showInformationMessage('No active editor!')
 						return
 					}
-
 					// create an area to show diffs
-					const diffArea: BaseDiffArea = {
+					const partialDiffArea: Omit<DiffArea, 'diffareaid'> = {
 						startLine: 0, // in ctrl+L the start and end lines are the full document
 						endLine: editor.document.lineCount,
 						originalStartLine: 0,
 						originalEndLine: editor.document.lineCount,
-						originalCode: await readFileContentOfUri(editor.document.uri),
+						sweepIndex: null,
 					}
-					displayChangesProvider.addDiffArea(editor.document.uri, diffArea)
+					const diffArea = diffProvider.createDiffArea(editor.document.uri, partialDiffArea, await readFileContentOfUri(editor.document.uri))
 
+					const docUri = editor.document.uri
+					const fileStr = await readFileContentOfUri(docUri)
+					const voidConfig = getVoidConfigFromPartial(context.globalState.get('partialVoidConfig') ?? {})
 
-					// write new code `m.code` to the document
-					// TODO update like this:
-					// this._weAreEditing = true
-					// await vscode.workspace.applyEdit(workspaceEdit)
-					// await vscode.workspace.save(docUri)
-					// this._weAreEditing = false
-					await editor.edit(editBuilder => {
-						editBuilder.replace(new vscode.Range(diffArea.startLine, 0, diffArea.endLine, Number.MAX_SAFE_INTEGER), m.code);
-					});
-
-					// rediff the changes based on the diffAreas
-					displayChangesProvider.refreshDiffAreas(editor.document.uri)
-
+					await applyDiffLazily({ docUri, oldFileStr: fileStr, diffRepr: m.diffRepr, voidConfig, diffProvider, diffArea, abortRef: abortApplyRef })
 				}
 				else if (m.type === 'getPartialVoidConfig') {
 					const partialVoidConfig = context.globalState.get('partialVoidConfig') ?? {}
@@ -132,6 +175,14 @@ export function activate(context: vscode.ExtensionContext) {
 					const updatedThreads: ChatThreads = { ...threads, [m.thread.id]: m.thread }
 					context.workspaceState.update('allThreads', updatedThreads)
 				}
+				else if (m.type === 'getDeviceId') {
+					let deviceId = context.globalState.get('void_deviceid')
+					if (!deviceId || typeof deviceId !== 'string') {
+						deviceId = uuidv4()
+						context.globalState.update('void_deviceid', deviceId)
+					}
+					webview.postMessage({ type: 'deviceId', deviceId: deviceId as string } satisfies MessageToSidebar)
+				}
 				else {
 					console.error('unrecognized command', m)
 				}
@@ -157,4 +208,3 @@ export function activate(context: vscode.ExtensionContext) {
 	// )
 
 }
-

extensions/void/src/extension/DiffProvider.ts

@@ -0,0 +1,560 @@
+import * as vscode from 'vscode';
+import { findDiffs } from './findDiffs';
+import { throttle } from 'lodash';
+import { DiffArea, BaseDiff, Diff } from '../common/shared_types';
+import { readFileContentOfUri } from './extensionLib/readFileContentOfUri';
+
+
+const THROTTLE_TIME = 100
+
+// TODO in theory this should be disposed
+const greenDecoration = vscode.window.createTextEditorDecorationType({
+	backgroundColor: 'rgba(0 255 51 / 0.2)',
+	isWholeLine: false, // after: { contentText: '       [original]', color: 'rgba(0 255 60 / 0.5)' }  // hoverMessage: originalText // this applies to hovering over after:...
+})
+const lightGrayDecoration = vscode.window.createTextEditorDecorationType({
+	backgroundColor: 'rgba(218 218 218 / .2)',
+	isWholeLine: true,
+})
+const darkGrayDecoration = vscode.window.createTextEditorDecorationType({
+	backgroundColor: 'rgb(148 148 148 / .2)',
+	isWholeLine: true,
+})
+
+// responsible for displaying diffs and showing accept/reject buttons
+export class DiffProvider implements vscode.CodeLensProvider {
+
+	private _originalFileOfDocument: { [docUriStr: string]: string } = {}
+	private _diffAreasOfDocument: { [docUriStr: string]: DiffArea[] } = {}
+	private _diffsOfDocument: { [docUriStr: string]: Diff[] } = {}
+
+	private _diffareaidPool = 0
+	private _diffidPool = 0
+
+	// used internally by vscode
+	private _onDidChangeCodeLenses: vscode.EventEmitter<void> = new vscode.EventEmitter<void>(); // signals a UI refresh on .fire() events
+	public readonly onDidChangeCodeLenses: vscode.Event<void> = this._onDidChangeCodeLenses.event;
+
+	// used internally by vscode
+	public provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.CodeLens[]> {
+		const docUriStr = document.uri.toString()
+		return this._diffsOfDocument[docUriStr]?.flatMap(diff => diff.lenses) ?? []
+	}
+
+	// declared by us, registered with vscode.languages.registerCodeLensProvider()
+	constructor() {
+
+		console.log('Creating DisplayChangesProvider')
+
+		// this acts as a useEffect every time text changes
+		vscode.workspace.onDidChangeTextDocument((e) => {
+
+			const editor = vscode.window.activeTextEditor
+
+			if (!editor) return
+
+			const docUriStr = editor.document.uri.toString()
+			const changes = e.contentChanges.map(c => ({ startLine: c.range.start.line, endLine: c.range.end.line, text: c.text, }))
+
+			// on user change, grow/shrink/merge/delete diff areas
+			this.refreshDiffAreasModel(docUriStr, changes, 'currentFile')
+
+			// refresh the diffAreas
+			this.refreshStylesAndDiffs(docUriStr)
+
+		})
+	}
+
+	// used by us only
+	public createDiffArea(uri: vscode.Uri, partialDiffArea: Omit<DiffArea, 'diffareaid'>, originalFile: string) {
+
+		const uriStr = uri.toString()
+
+		this._originalFileOfDocument[uriStr] = originalFile
+
+		// make sure array is defined
+		if (!this._diffAreasOfDocument[uriStr]) this._diffAreasOfDocument[uriStr] = []
+
+		// remove all diffAreas that the new `diffArea` is overlapping with
+		this._diffAreasOfDocument[uriStr] = this._diffAreasOfDocument[uriStr].filter(da => {
+			const noOverlap = da.startLine > partialDiffArea.endLine || da.endLine < partialDiffArea.startLine
+			if (!noOverlap) return false
+			return true
+		})
+
+		// add `diffArea` to storage
+		const diffArea = {
+			...partialDiffArea,
+			diffareaid: this._diffareaidPool
+		}
+		this._diffAreasOfDocument[uriStr].push(diffArea)
+		this._diffareaidPool += 1
+
+		return diffArea
+	}
+
+	// used by us only
+	// changes the start/line locations based on the changes that were recently made. does not change any of the diffs in the diff areas
+	// changes tells us how many lines were inserted/deleted so we can grow/shrink the diffAreas accordingly
+	public refreshDiffAreasModel(docUriStr: string, changes: { text: string, startLine: number, endLine: number }[], changesTo: 'originalFile' | 'currentFile') {
+
+		const diffAreas = this._diffAreasOfDocument[docUriStr] || []
+
+		let endName
+		let startName
+		if (changesTo === 'originalFile') {
+			endName = 'originalEndLine' as const
+			startName = 'originalStartLine' as const
+		} else {
+			endName = 'endLine' as const
+			startName = 'startLine' as const
+		}
+
+		for (const change of changes) {
+
+			// here, `change.range` is the range of the original file that gets replaced with `change.text`
+
+
+			// compute net number of newlines lines that were added/removed
+			const numNewLines = (change.text.match(/\n/g) || []).length
+			const numLineDeletions = change.endLine - change.startLine
+			const deltaNewlines = numNewLines - numLineDeletions
+
+			// compute overlap with each diffArea and shrink/elongate the diffArea accordingly
+			for (const diffArea of diffAreas) {
+
+				// if the change is fully within the diffArea, elongate it by the delta amount of newlines
+				if (change.startLine >= diffArea[startName] && change.endLine <= diffArea[endName]) {
+					diffArea[endName] += deltaNewlines
+				}
+				// check if the `diffArea` was fully deleted and remove it if so
+				if (diffArea[startName] > diffArea[endName]) {
+					//remove it
+					const index = diffAreas.findIndex(da => da === diffArea)
+					diffAreas.splice(index, 1)
+				}
+
+				// TODO handle other cases where eg. the change overlaps many diffAreas
+			}
+
+
+			// if a diffArea is below the last character of the change, shift the diffArea up/down by the delta amount of newlines
+			for (const diffArea of diffAreas) {
+				if (diffArea[startName] > change.endLine) {
+					diffArea[startName] += deltaNewlines
+					diffArea[endName] += deltaNewlines
+				}
+			}
+
+			// TODO merge any diffAreas if they overlap with each other as a result from the shift
+
+		}
+	}
+
+
+	// used by us only
+	// refreshes all the diffs inside each diff area, and refreshes the styles
+	public refreshStylesAndDiffs(docUriStr: string) {
+
+		const editor = vscode.window.activeTextEditor // TODO the editor should be that of `docUri` and not necessarily the current editor
+		if (!editor) {
+			console.log('Error: No active editor!')
+			return;
+		}
+		const originalFile = this._originalFileOfDocument[docUriStr]
+		if (!originalFile) {
+			console.log('Error: No original file!')
+			return;
+		}
+
+		const diffAreas = this._diffAreasOfDocument[docUriStr] || []
+
+		// reset all diffs (we update them below)
+		this._diffsOfDocument[docUriStr] = []
+
+		// for each diffArea
+		for (const diffArea of diffAreas) {
+
+			// get code inside of diffArea
+			const originalCode = originalFile.split('\n').slice(diffArea.originalStartLine, diffArea.originalEndLine + 1).join('\n')
+			const currentCode = editor.document.getText(new vscode.Range(diffArea.startLine, 0, diffArea.endLine, Number.MAX_SAFE_INTEGER)).replace(/\r\n/g, '\n')
+
+			// compute the diffs
+			const diffs = findDiffs(originalCode, currentCode)
+
+			// 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')))
+			// console.log('!AREA originalCode:', JSON.stringify(originalCode))
+			// console.log('!AREA currentCode :', JSON.stringify(currentCode))
+			// for (const diff of this._diffsOfDocument[docUriStr]) {
+			// 	console.log('------------')
+			// 	console.log('originalCode:', JSON.stringify(diff.originalCode))
+			// 	console.log('currentCode:', JSON.stringify(diff.code))
+			// 	console.log('originalRange:', diff.originalRange.start.line, diff.originalRange.end.line,)
+			// 	console.log('currentRange:', diff.range.start.line, diff.range.end.line,)
+			// }
+
+		}
+
+		// update green highlighting
+		editor.setDecorations(
+			greenDecoration,
+			(this._diffsOfDocument[docUriStr]
+				.filter(diff => diff.range !== undefined)
+				.map(diff => diff.range)
+			)
+		);
+
+
+		// for each diffArea, highlight its sweepIndex in dark gray
+		editor.setDecorations(
+			darkGrayDecoration,
+			(this._diffAreasOfDocument[docUriStr]
+				.filter(diffArea => diffArea.sweepIndex !== null)
+				.map(diffArea => {
+					let s = diffArea.sweepIndex!
+					return new vscode.Range(s, 0, s, 0)
+				})
+			)
+		)
+
+		// for each diffArea, highlight sweepIndex+1...end in light gray
+		editor.setDecorations(
+			lightGrayDecoration,
+			(this._diffAreasOfDocument[docUriStr]
+				.filter(diffArea => diffArea.sweepIndex !== null)
+				.map(diffArea => {
+					return new vscode.Range(diffArea.sweepIndex! + 1, 0, diffArea.endLine, 0)
+				})
+			)
+		)
+
+		// TODO update red highlighting
+		// this._diffsOfDocument[docUriStr].map(diff => diff.deletedCode)
+
+		// update code lenses
+		this._onDidChangeCodeLenses.fire()
+
+	}
+
+	// used by us only
+	public createDiffs(docUri: vscode.Uri, diffs: BaseDiff[], diffArea: DiffArea) {
+
+		const docUriStr = docUri.toString()
+
+		// if no diffs, set diffs to []
+		if (!this._diffsOfDocument[docUriStr])
+			this._diffsOfDocument[docUriStr] = []
+
+		// add each diff and its codelens to the document
+		for (let i = diffs.length - 1; i > -1; i -= 1) {
+			let suggestedDiff = diffs[i]
+
+			this._diffsOfDocument[docUriStr].push({
+				...suggestedDiff,
+				diffid: this._diffidPool,
+				// originalCode: suggestedDiff.deletedText,
+				lenses: [
+					new vscode.CodeLens(suggestedDiff.range, { title: 'Accept', command: 'void.acceptDiff', arguments: [{ diffid: this._diffidPool, diffareaid: diffArea.diffareaid }] }),
+					new vscode.CodeLens(suggestedDiff.range, { title: 'Reject', command: 'void.rejectDiff', arguments: [{ diffid: this._diffidPool, diffareaid: diffArea.diffareaid }] })
+				]
+			});
+			this._diffidPool += 1
+		}
+
+	}
+
+	// called on void.acceptDiff
+	public async acceptDiff({ diffid, diffareaid }: { diffid: number, diffareaid: number }) {
+		const editor = vscode.window.activeTextEditor
+		if (!editor)
+			return
+
+		const docUriStr = editor.document.uri.toString()
+
+		const diffIdx = this._diffsOfDocument[docUriStr].findIndex(diff => diff.diffid === diffid);
+		if (diffIdx === -1) { console.error('Error: DiffID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return; }
+
+		const diffareaIdx = this._diffAreasOfDocument[docUriStr].findIndex(diff => diff.diffareaid === diffareaid);
+		if (diffareaIdx === -1) { console.error('Error: DiffAreaID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return; }
+
+		const diff = this._diffsOfDocument[docUriStr][diffIdx]
+		const originalFile = this._originalFileOfDocument[docUriStr]
+		const currentFile = await readFileContentOfUri(editor.document.uri)
+
+		// Fixed: Handle newlines properly by splitting into lines and joining with proper newlines
+		const originalLines = originalFile.split('\n');
+		const currentLines = currentFile.split('\n');
+
+		// Get the changed lines from current file
+		const changedLines = currentLines.slice(diff.range.start.line, diff.range.end.line + 1);
+
+		// Create new original file content by replacing the affected lines
+		const newOriginalLines = [
+			...originalLines.slice(0, diff.originalRange.start.line),
+			...changedLines,
+			...originalLines.slice(diff.originalRange.end.line + 1)
+		];
+
+		this._originalFileOfDocument[docUriStr] = newOriginalLines.join('\n');
+
+		// Update diff areas based on the change
+		this.refreshDiffAreasModel(docUriStr, [{
+			text: changedLines.join('\n'),
+			startLine: diff.originalRange.start.line,
+			endLine: diff.originalRange.end.line
+		}], 'originalFile')
+
+		// Check if diffArea should be removed
+
+		const diffArea = this._diffAreasOfDocument[docUriStr][diffareaIdx]
+
+		const currentArea = currentLines.slice(diffArea.startLine, diffArea.endLine + 1).join('\n')
+		const originalArea = newOriginalLines.slice(diffArea.originalStartLine, diffArea.originalEndLine + 1).join('\n')
+
+		console.log('ACCEPT change', changedLines.join('\n'), diff.originalRange.start.line, diff.originalRange.end.line)
+		console.log('ACCEPT area lines', diffArea.startLine, diffArea.endLine, diffArea.originalStartLine, diffArea.originalEndLine)
+		console.log('ACCEPT currentArea', currentArea)
+		console.log('ACCEPT originalArea', originalArea)
+
+		if (originalArea === currentArea) {
+			const index = this._diffAreasOfDocument[docUriStr].findIndex(da => da.diffareaid === diffArea.diffareaid)
+			this._diffAreasOfDocument[docUriStr].splice(index, 1)
+		}
+
+		this.refreshStylesAndDiffs(docUriStr)
+	}
+
+	// called on void.rejectDiff
+	public async rejectDiff({ diffid, diffareaid }: { diffid: number, diffareaid: number }) {
+		const editor = vscode.window.activeTextEditor
+		if (!editor)
+			return
+
+		const docUriStr = editor.document.uri.toString()
+
+		const diffIdx = this._diffsOfDocument[docUriStr].findIndex(diff => diff.diffid === diffid);
+		if (diffIdx === -1) { console.error('Error: DiffID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return; }
+
+		const diffareaIdx = this._diffAreasOfDocument[docUriStr].findIndex(diff => diff.diffareaid === diffareaid);
+		if (diffareaIdx === -1) { console.error('Error: DiffAreaID could not be found: ', diffid, diffareaid, this._diffsOfDocument[docUriStr], this._diffAreasOfDocument[docUriStr]); return; }
+
+		const diff = this._diffsOfDocument[docUriStr][diffIdx]
+
+		// Apply the rejection by replacing with original code
+		// we don't have to edit the original or final file; just do a workspace edit so the code equals the original code
+		const workspaceEdit = new vscode.WorkspaceEdit();
+		workspaceEdit.replace(editor.document.uri, diff.range, diff.originalCode)
+		await vscode.workspace.applyEdit(workspaceEdit)
+
+		// Check if diffArea should be removed
+		const originalFile = this._originalFileOfDocument[docUriStr]
+		const currentFile = await readFileContentOfUri(editor.document.uri)
+		const diffArea = this._diffAreasOfDocument[docUriStr][diffareaIdx]
+		const currentLines = currentFile.split('\n');
+		const originalLines = originalFile.split('\n');
+
+		const currentArea = currentLines.slice(diffArea.startLine, diffArea.endLine + 1).join('\n')
+		const originalArea = originalLines.slice(diffArea.originalStartLine, diffArea.originalEndLine + 1).join('\n')
+
+		console.log('REJECT diff lines', diff.originalRange.start.line, diff.originalRange.end.line)
+		console.log('REJECT area lines', diffArea.startLine, diffArea.endLine, diffArea.originalStartLine, diffArea.originalEndLine)
+		console.log('REJECT currentArea', currentArea)
+		console.log('REJECT originalArea', originalArea)
+
+		if (originalArea === currentArea) {
+			const index = this._diffAreasOfDocument[docUriStr].findIndex(da => da.diffareaid === diffArea.diffareaid)
+			this._diffAreasOfDocument[docUriStr].splice(index, 1)
+		}
+
+		this.refreshStylesAndDiffs(docUriStr)
+	}
+
+
+
+
+	// used by us only
+	public updateStream = throttle(async (docUriStr: string, diffArea: DiffArea, newDiffAreaCode: string) => {
+
+		const editor = vscode.window.activeTextEditor // TODO the editor should be that of `docUri` and not necessarily the current editor
+		if (!editor) {
+			console.log('Error: No active editor!')
+			return;
+		}
+
+		// original code all diffs are based on in the code
+		const originalDiffAreaCode = (this._originalFileOfDocument[docUriStr] || '').split('\n').slice(diffArea.originalStartLine, diffArea.originalEndLine + 1).join('\n')
+
+		// 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
+
+		// these are two different coordinate systems - new and old line number
+		let newFileEndLine: number // get new[0...newStoppingPoint] with line=newStoppingPoint highlighted
+		let oldFileStartLine: number // get original[oldStartingPoint...]
+
+		if (!lastDiff) {
+			// if the writing is identical so far, display no changes
+			newFileEndLine = 0
+			oldFileStartLine = 0
+		}
+		else {
+			if (lastDiff.type === 'insertion') {
+				newFileEndLine = lastDiff.range.end.line
+				oldFileStartLine = lastDiff.originalRange.start.line
+			}
+			else if (lastDiff.type === 'deletion') {
+				newFileEndLine = lastDiff.range.start.line
+				oldFileStartLine = lastDiff.originalRange.start.line
+			}
+			else if (lastDiff.type === 'edit') {
+				newFileEndLine = lastDiff.range.end.line
+				oldFileStartLine = lastDiff.originalRange.start.line
+			}
+			else {
+				throw new Error(`updateStream: diff.type not recognized: ${lastDiff.type}`)
+			}
+		}
+
+		// display
+		const newFileTop = newDiffAreaCode.split('\n').slice(0, newFileEndLine + 1).join('\n')
+		const oldFileBottom = originalDiffAreaCode.split('\n').slice(oldFileStartLine + 1, Infinity).join('\n')
+
+		let newCode = `${newFileTop}\n${oldFileBottom}`
+		diffArea.sweepIndex = newFileEndLine
+		// replace oldDACode with newDACode with a vscode edit
+
+		const workspaceEdit = new vscode.WorkspaceEdit();
+
+		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)
+
+}
+
+
+
+
+/*
+import * as vscode from 'vscode';
+import { SuggestedEdit } from './findDiffs';
+
+const greenDecoration = vscode.window.createTextEditorDecorationType({
+	backgroundColor: 'rgba(0 255 51 / 0.2)',
+	isWholeLine: false, // after: { contentText: '       [original]', color: 'rgba(0 255 60 / 0.5)' }  // hoverMessage: originalText // this applies to hovering over after:...
+})
+
+
+
+
+export class DiffProvider {
+
+	originalCodeOfDocument: { [docUri: string]: string }
+
+	diffsOfDocument: {
+		[docUri: string]: {
+			startLine,
+			startCol,
+			endLine,
+			endCol,
+			originalText,
+
+			inset,
+			diffid,
+		}
+	}
+
+	// sweep
+	currentLine: { [docUri: string]: undefined | number }
+	weAreEditing: boolean = false
+
+
+	constructor() {
+
+		vscode.workspace.onDidChangeTextDocument((e) => {
+			// on user change, grow/shrink/merge/delete diff AREAS
+			// you dont have to do anything to the diffs here bc they all get recomputed in refresh()
+			// user changes only get highlighted if theyre in a diffarea
+
+			// go thru all diff areas and adjust line numbers based on the user's change
+
+
+			this.refreshStyles(e.document.uri.toString())
+		})
+
+	}
+
+
+
+	// refreshes styles on page
+	refreshStyles(docUriStr: string) {
+
+		if (this.weAreEditing) return
+
+		// recompute all diffs on the page
+		// run inset.dispose() on all diffs
+
+		// original and current code -> diffs
+		// originalCodeOfDocument[docUriStr]
+
+		// create new diffs
+		const inset = vscode.window.createWebviewTextEditorInset(editor, lineStart, height, {})
+		inset.webview.html = `
+			<html>
+				<body style="pointer-events:none;">Hello World!</body>
+			</html>
+			`;
+
+	}
+
+	// called on void.acceptDiff
+	public async acceptDiff({ diffid }: { diffid: number }) {
+
+		// update original based on the diff
+		// refresh()
+
+	}
+
+
+	// called on void.rejectDiff
+	public async rejectDiff({ diffid }: { diffid: number }) {
+
+		// get diffs[diffid]
+
+		// revert current file based on diff
+		// refresh()
+
+	}
+
+
+
+
+	// sweep
+	initializeSweep({ startLine }) {
+		// reject all diffs on the page
+		// store original code
+		// currentLine=start of sweep
+	}
+
+	onUpdateSweep(addedText) {
+		// update final
+		// refresh() ?
+		// currentLine += number of newlines in addedText
+	}
+
+	onAbortSweep() {
+
+	}
+
+
+
+}
+
+
+*/

extensions/void/src/extension/ctrlL.ts

@@ -0,0 +1,185 @@
+import * as vscode from 'vscode';
+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
+
+
+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 }) => {
+
+	const NUM_MATCHUP_TOKENS = 20
+
+	const promptContent = `ORIGINAL_FILE
+\`\`\`
+${oldFileStr}
+\`\`\`
+
+DIFF
+\`\`\`
+${diffRepr}
+\`\`\`
+
+INSTRUCTIONS
+Please finish writing the new file \`NEW_FILE\`. Return ONLY the completion of the file, without any explanation.
+
+NEW_FILE
+\`\`\`
+${completedStr}
+\`\`\`
+`
+	// create a promise that can be awaited
+	return new Promise<CompetedReturn>((resolve, reject) => {
+
+		let isAnyChangeSoFar = false
+
+		// make LLM complete the file to include the diff
+		sendLLMMessage({
+			messages: [{ role: 'system', content: writeFileWithDiffInstructions, }, { role: 'user', content: promptContent, }],
+			onText: (newText, fullText) => {
+				const fullCompletedStr = completedStr + fullText
+
+				diffProvider.updateStream(docUri.toString(), diffArea, fullCompletedStr)
+
+				// if there was any change from the original file
+				if (!oldFileStr.includes(fullCompletedStr)) {
+					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
+
+				if (isAnyChangeSoFar && isRecentMatchup) {
+					diffProvider.updateStream(docUri.toString(), diffArea, fullCompletedStr)
+
+					// TODO resolve the promise
+					// resolve({ speculativeIndex: newCurrentLine + 1 });
+
+					// abort the LLM call
+					abortRef.current?.()
+
+				}
+
+			},
+
+			onFinalMessage: (fullText) => {
+				const newCompletedStr = completedStr + fullText
+				diffProvider.updateStream(docUri.toString(), diffArea, newCompletedStr)
+				resolve({ isFinished: true });
+			},
+			onError: (e) => {
+				resolve({ isFinished: true });
+				console.error('Error rewriting file with diff', e);
+			},
+			voidConfig,
+			abortRef,
+		})
+	})
+}
+
+
+const shouldApplyDiff = ({ diffRepr, oldFileStr: fileStr, speculationStr, voidConfig, abortRef }: { diffRepr: string, oldFileStr: string, speculationStr: string, voidConfig: VoidConfig, abortRef: AbortRef }) => {
+
+	const promptContent = `DIFF
+\`\`\`
+${diffRepr}
+\`\`\`
+
+FILES
+\`\`\`
+${fileStr}
+\`\`\`
+
+SELECTION
+\`\`\`
+${speculationStr}
+\`\`\`
+
+Return \`true\` if ANY part of the chunk should be modified, and \`false\` if it should not be modified. You should respond only with \`true\` or \`false\` and nothing else.
+`
+
+	// create new promise
+	return new Promise<boolean>((resolve, reject) => {
+		// send message to LLM
+		sendLLMMessage({
+			messages: [{ role: 'system', content: searchDiffChunkInstructions, }, { role: 'user', content: promptContent, }],
+			onFinalMessage: (finalMessage) => {
+
+				const containsTrue = finalMessage
+					.slice(-10) // check for `true` in last 10 characters
+					.toLowerCase()
+					.includes('true')
+
+				resolve(containsTrue)
+			},
+			onError: (e) => {
+				resolve(false);
+				console.error('Error in shouldApplyDiff: ', e)
+			},
+			onText: () => { },
+			voidConfig,
+			abortRef,
+		})
+
+	})
+
+}
+
+
+
+// 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 }) => {
+
+
+	// stateful variables
+	let speculativeIndex = 0
+	let writtenTextSoFar: string[] = []
+
+	while (speculativeIndex < oldFileStr.split('\n').length) {
+
+		const chunkStr = oldFileStr.split('\n').slice(speculativeIndex, speculativeIndex + LINES_PER_CHUNK).join('\n')
+
+		// ask LLM if we should apply the diff to the chunk
+		const START = new Date().getTime()
+		let shouldApplyDiff_ = await shouldApplyDiff({ oldFileStr, speculationStr: chunkStr, diffRepr, voidConfig, abortRef })
+		const END = new Date().getTime()
+
+		// if should not change the chunk
+		if (!shouldApplyDiff_) {
+			console.log('KEEP CHUNK time: ', END - START)
+			speculativeIndex += LINES_PER_CHUNK
+			writtenTextSoFar.push(chunkStr)
+			diffProvider.updateStream(docUri.toString(), diffArea, writtenTextSoFar.join('\n'))
+			continue;
+		}
+
+		// ask LLM to rewrite file with diff (if there is significant matchup with the original file, we stop rewriting)
+		const START2 = new Date().getTime()
+		const completedStr = (await readFileContentOfUri(docUri)).split('\n').slice(0, speculativeIndex).join('\n');
+		const result = await streamChunk({ diffProvider, docUri, oldFileStr, completedStr, diffRepr, voidConfig, diffArea, abortRef, })
+		const END2 = new Date().getTime()
+
+		console.log('EDIT CHUNK time: ', END2 - START2);
+
+		// if we are finished, stop the loop
+		if (result.isFinished) {
+			break;
+		}
+
+		// TODO
+		// speculativeIndex = result.speculativeIndex
+
+	}
+
+
+}
+
+
+
+export { applyDiffLazily }

extensions/void/src/extension/extension.ts

@@ -0,0 +1,203 @@
+import * as vscode from 'vscode';
+import { applyDiffLazily } from './ctrlL';
+import { readFileContentOfUri } from './extensionLib/readFileContentOfUri';
+import { MessageToSidebar, MessageFromSidebar, DiffArea, ChatThreads } from '../common/shared_types';
+import { DiffProvider } from './DiffProvider';
+import { getVoidConfigFromPartial } from '../webviews/common/contextForConfig';
+import { CtrlKWebviewProvider } from './providers/CtrlKWebviewProvider';
+import { SidebarWebviewProvider } from './providers/SidebarWebviewProvider';
+import { v4 as uuidv4 } from 'uuid'
+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;
+	}
+}
+
+const roundRangeToLines = (selection: vscode.Selection) => {
+	return new vscode.Range(selection.start.line, 0, selection.end.line, Number.MAX_SAFE_INTEGER)
+}
+
+export function activate(context: vscode.ExtensionContext) {
+
+	// 1. Mount the chat sidebar
+	const sidebarWebviewProvider = new SidebarWebviewProvider(context);
+	context.subscriptions.push(
+		vscode.window.registerWebviewViewProvider(SidebarWebviewProvider.viewId, sidebarWebviewProvider, { webviewOptions: { retainContextWhenHidden: true } })
+	);
+
+	// 1.5
+	const ctrlKWebviewProvider = new CtrlKWebviewProvider(context)
+
+
+	// 2. ctrl+l
+	context.subscriptions.push(
+		vscode.commands.registerCommand('void.ctrl+l', () => {
+			const editor = vscode.window.activeTextEditor
+			if (!editor) return
+
+			// show the sidebar
+			vscode.commands.executeCommand('workbench.view.extension.voidViewContainer');
+			// vscode.commands.executeCommand('vscode.moveViewToPanel', CustomViewProvider.viewId); // move to aux bar
+
+			// get the 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;
+
+			// send message to the webview (Sidebar.tsx)
+			sidebarWebviewProvider.webview.then(webview => webview.postMessage({ type: 'ctrl+l', selection: { selectionStr, selectionRange, filePath } } satisfies MessageToSidebar));
+		})
+	);
+
+	// 2.5: ctrl+k
+	context.subscriptions.push(
+		vscode.commands.registerCommand('void.ctrl+k', () => {
+			console.log('CTRLK PRESSED')
+			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;
+
+			// send message to the webview (Sidebar.tsx)
+			ctrlKWebviewProvider.onPressCtrlK()
+		})
+	);
+
+	// 3. Show an approve/reject codelens above each change
+	const diffProvider = new DiffProvider();
+	context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', diffProvider));
+
+	// 4. Add approve/reject commands
+	context.subscriptions.push(vscode.commands.registerCommand('void.acceptDiff', async (params) => {
+		diffProvider.acceptDiff(params)
+	}));
+	context.subscriptions.push(vscode.commands.registerCommand('void.rejectDiff', async (params) => {
+		diffProvider.rejectDiff(params)
+	}));
+
+	// 5. Receive messages from sidebar
+	sidebarWebviewProvider.webview.then(
+		webview => {
+
+			// top navigation bar commands
+			context.subscriptions.push(vscode.commands.registerCommand('void.startNewThread', async () => {
+				webview.postMessage({ type: 'startNewThread' } satisfies MessageToSidebar)
+			}))
+			context.subscriptions.push(vscode.commands.registerCommand('void.toggleThreadSelector', async () => {
+				webview.postMessage({ type: 'toggleThreadSelector' } satisfies MessageToSidebar)
+			}))
+			context.subscriptions.push(vscode.commands.registerCommand('void.toggleSettings', async () => {
+				webview.postMessage({ type: 'toggleSettings' } satisfies MessageToSidebar)
+			}));
+
+			// Receive messages in the extension from the sidebar webview (messages are sent using `postMessage`)
+			webview.onDidReceiveMessage(async (m: MessageFromSidebar) => {
+
+				const abortApplyRef: AbortRef = { current: null }
+
+				if (m.type === 'requestFiles') {
+
+					// get contents of all file paths
+					const files = await Promise.all(
+						m.filepaths.map(async (filepath) => ({ filepath, content: await readFileContentOfUri(filepath) }))
+					)
+
+					// send contents to webview
+					webview.postMessage({ type: 'files', files, } satisfies MessageToSidebar)
+
+				}
+				else if (m.type === 'applyChanges') {
+
+					const editor = vscode.window.activeTextEditor
+					if (!editor) {
+						vscode.window.showInformationMessage('No active editor!')
+						return
+					}
+					// create an area to show diffs
+					const partialDiffArea: Omit<DiffArea, 'diffareaid'> = {
+						startLine: 0, // in ctrl+L the start and end lines are the full document
+						endLine: editor.document.lineCount,
+						originalStartLine: 0,
+						originalEndLine: editor.document.lineCount,
+						sweepIndex: null,
+					}
+					const diffArea = diffProvider.createDiffArea(editor.document.uri, partialDiffArea, await readFileContentOfUri(editor.document.uri))
+
+					const docUri = editor.document.uri
+					const fileStr = await readFileContentOfUri(docUri)
+					const voidConfig = getVoidConfigFromPartial(context.globalState.get('partialVoidConfig') ?? {})
+
+					await applyDiffLazily({ docUri, oldFileStr: fileStr, diffRepr: m.diffRepr, voidConfig, diffProvider, diffArea, abortRef: abortApplyRef })
+				}
+				else if (m.type === 'getPartialVoidConfig') {
+					const partialVoidConfig = context.globalState.get('partialVoidConfig') ?? {}
+					webview.postMessage({ type: 'partialVoidConfig', partialVoidConfig } satisfies MessageToSidebar)
+				}
+				else if (m.type === 'persistPartialVoidConfig') {
+					const partialVoidConfig = m.partialVoidConfig
+					context.globalState.update('partialVoidConfig', partialVoidConfig)
+				}
+				else if (m.type === 'getAllThreads') {
+					const threads: ChatThreads = context.workspaceState.get('allThreads') ?? {}
+					webview.postMessage({ type: 'allThreads', threads } satisfies MessageToSidebar)
+				}
+				else if (m.type === 'persistThread') {
+					const threads: ChatThreads = context.workspaceState.get('allThreads') ?? {}
+					const updatedThreads: ChatThreads = { ...threads, [m.thread.id]: m.thread }
+					context.workspaceState.update('allThreads', updatedThreads)
+				}
+				else if (m.type === 'getDeviceId') {
+					let deviceId = context.globalState.get('void_deviceid')
+					if (!deviceId || typeof deviceId !== 'string') {
+						deviceId = uuidv4()
+						context.globalState.update('void_deviceid', deviceId)
+					}
+					webview.postMessage({ type: 'deviceId', deviceId: deviceId as string } satisfies MessageToSidebar)
+				}
+				else {
+					console.error('unrecognized command', m)
+				}
+			})
+		}
+	)
+
+
+
+
+	// Gets called when user presses ctrl + k (mounts ctrl+k-style codelens)
+	// TODO need to build this
+	// const ctrlKCodeLensProvider = new CtrlKCodeLensProvider();
+	// context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', ctrlKCodeLensProvider));
+	// context.subscriptions.push(
+	// 	vscode.commands.registerCommand('void.ctrl+k', () => {
+	// 		const editor = vscode.window.activeTextEditor;
+	// 		if (!editor)
+	// 			return
+	// 		ctrlKCodeLensProvider.addNewCodeLens(editor.document, editor.selection);
+	// 		// vscode.commands.executeCommand('editor.action.showHover'); // apparently this refreshes the codelenses by having the internals call provideCodeLenses
+	// 	})
+	// )
+
+}

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

@@ -0,0 +1,14 @@
+import * as vscode from 'vscode'
+
+
+export const readFileContentOfUri = async (uri: vscode.Uri): Promise<string> => {
+	const document = await vscode.workspace.openTextDocument(uri);
+	return document.getText().replace(/\r\n/g, '\n') ?? '' // Normalize line endings
+
+};
+
+// this is the old version, which only reads the most recently saved version
+// export const readFileContentOfUri = async (uri: vscode.Uri) => {
+// 	return Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf8')
+// 		.replace(/\r\n/g, '\n') // replace windows \r\n with \n
+// }

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

@@ -0,0 +1,132 @@
+
+import { Range } from 'vscode';
+import { diffLines, Change } from 'diff';
+import { BaseDiff } from '../common/shared_types';
+
+
+
+// class Range {
+// 	range: any;
+// 	constructor(startLine, startCol, endLine, endCol) {
+// 	  const range = {
+// 		startLine,
+// 		startCol,
+// 		endLine,
+// 		endCol,
+// 	  };
+// 	  this.range = range;
+// 	}
+//   }
+
+
+
+// Andrew diff algo:
+export type SuggestedEdit = {
+	// start/end of current file
+	newRange: Range;
+
+	// start/end of original file
+	originalRange: Range;
+	type: 'insertion' | 'deletion' | 'edit',
+	originalContent: string, // original content (originalfile[originalStart...originalEnd])
+	newContent: string,
+}
+
+export function findDiffs(oldStr: string, newStr: string) {
+	// an ordered list of every original line, line added to the new file, and line removed from the old file (order is unambiguous, think about it)
+	const lineByLineChanges: Change[] = diffLines(oldStr, newStr);
+	lineByLineChanges.push({ value: '' }) // add a dummy so we flush any streaks we haven't yet at the very end (!line.added && !line.removed)
+
+	let oldFileLineNum: number = 0;
+	let newFileLineNum: number = 0;
+
+	let streakStartInNewFile: number | undefined = undefined
+	let streakStartInOldFile: number | undefined = undefined
+
+	let oldStrLines = oldStr.split('\n')
+	let newStrLines = newStr.split('\n')
+
+	const replacements: BaseDiff[] = []
+	for (let line of lineByLineChanges) {
+
+		// no change on this line
+		if (!line.added && !line.removed) {
+
+			// do nothing
+
+			// if we were on a streak of +s and -s, end it
+			if (streakStartInNewFile !== undefined) {
+				let type: 'edit' | 'insertion' | 'deletion' = 'edit'
+
+				let startLine = streakStartInNewFile
+				let endLine = newFileLineNum - 1 // don't include current line, the edit was up to this line but not including it
+				let startCol = 0
+				let endCol = Number.MAX_SAFE_INTEGER
+
+				let originalStartLine = streakStartInOldFile!
+				let originalEndLine = oldFileLineNum - 1 // don't include current line, the edit was up to this line but not including it
+				let originalStartCol = 0
+				let originalEndCol = Number.MAX_SAFE_INTEGER
+
+				let newContent = newStrLines.slice(startLine, endLine + 1).join('\n')
+				let originalContent = oldStrLines.slice(originalStartLine, originalEndLine + 1).join('\n')
+
+				// if the range is empty, mark it as a deletion / insertion (both won't be true at once)
+				// DELETION
+				if (endLine === startLine - 1) {
+					type = 'deletion'
+					endLine = startLine
+					startCol = 0
+					endCol = 0
+					newContent += '\n'
+				}
+
+				// INSERTION
+				else if (originalEndLine === originalStartLine - 1) {
+					type = 'insertion'
+					originalEndLine = originalStartLine
+					originalStartCol = 0
+					originalEndCol = 0
+				}
+
+				const replacement: BaseDiff = {
+					type,
+					range: new Range(startLine, startCol, endLine, endCol),
+					code: newContent,
+					originalRange: new Range(originalStartLine, originalStartCol, originalEndLine, originalEndCol),
+					originalCode: originalContent,
+				}
+
+				replacements.push(replacement)
+
+				streakStartInNewFile = undefined
+				streakStartInOldFile = undefined
+			}
+			oldFileLineNum += line.count ?? 0;
+			newFileLineNum += line.count ?? 0;
+		}
+
+		// line was removed from old file
+		else if (line.removed) {
+			// if we weren't on a streak, start one on this current line num
+			if (streakStartInNewFile === undefined) {
+				streakStartInNewFile = newFileLineNum
+				streakStartInOldFile = oldFileLineNum
+			}
+			oldFileLineNum += line.count ?? 0 // we processed the line so add 1
+		}
+
+		// line was added to new file
+		else if (line.added) {
+			// if we weren't on a streak, start one on this current line num
+			if (streakStartInNewFile === undefined) {
+				streakStartInNewFile = newFileLineNum
+				streakStartInOldFile = oldFileLineNum
+			}
+			newFileLineNum += line.count ?? 0; // we processed the line so add 1
+		}
+	} // end for
+
+	console.debug('Replacements', replacements)
+	return replacements
+}

extensions/void/src/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/findDiffs.ts

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

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

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

extensions/void/src/sidebar/index.tsx

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

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

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

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

@@ -45,6 +45,11 @@ const voidConfigInfo: Record<
 			'anthropic',
 			configFields,
 		),
+
+		maxTokens: configString(
+			"Max number of tokens to output. Must be a number.", ''
+		),
+
 	},
 	anthropic: {
 		apikey: configString('Anthropic API key.', ''),
@@ -58,17 +63,6 @@ const voidConfigInfo: Record<
 				"claude-3-haiku-20240307"
 			] as const,
 		),
-
-		maxTokens: configEnum(
-			"Anthropic max number of tokens to output.",
-			'8192',
-			[
-				"1024",
-				"2048",
-				"4096",
-				"8192"
-			] as const,
-		),
 	},
 	openAI: {
 		apikey: configString('OpenAI API key.', ''),
@@ -112,101 +106,15 @@ const voidConfigInfo: Record<
 	},
 	ollama: {
 		endpoint: configString(
-			'The Ollama endpoint. Start Ollama by running `OLLAMA_ORIGINS="vscode-webview://*" ollama serve`',
+			'The endpoint of your Ollama instance. Start Ollama by running `OLLAMA_ORIGINS="vscode-webview://*" ollama serve`.',
 			'http://127.0.0.1:11434'
 		),
-		model: configEnum(
-			'Ollama model to use.',
-			'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
-		),
+		// 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
+		// ),
 	},
 	openRouter: {
 		model: configString(
@@ -216,7 +124,7 @@ const voidConfigInfo: Record<
 		apikey: configString('OpenRouter API key.', ''),
 	},
 	openAICompatible: {
-		endpoint: configString('The endpoint.', 'http://127.0.0.1:11434/v1'),
+		endpoint: configString('The baseUrl (exluding /chat/completions).', 'http://127.0.0.1:11434/v1'),
 		model: configString('The name of the model to use.', 'gpt-4o'),
 		apikey: configString('Your API key.', ''),
 	},
@@ -270,18 +178,18 @@ export type VoidConfig = {
 
 
 
-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
@@ -319,7 +227,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])
@@ -339,7 +247,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 })
 			}

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

@@ -0,0 +1,25 @@
+import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
+
+type PropsType = { [s: string]: any } | null
+
+type PropsValue = { props: PropsType }
+
+const PropsContext = createContext<PropsValue>(undefined as unknown as PropsValue)
+
+// provider for whatever came in data-void-props
+export function PropsProvider({ children, props }: { children: ReactNode, props: PropsType }) {
+	return (
+		<PropsContext.Provider value={{ props }}>
+			{children}
+		</PropsContext.Provider>
+	)
+}
+
+export function useVoidProps(): PropsValue {
+	const context = useContext<PropsValue>(PropsContext)
+	if (context === undefined) {
+		throw new Error("useVoidProps missing Provider")
+	}
+	return context
+}
+

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

@@ -1,12 +1,12 @@
 import React, { ReactNode, createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"
-import { ChatMessage, ChatThreads } from "../shared_types"
+import { ChatMessage, ChatThreads } from "../../common/shared_types"
 import { awaitVSCodeResponse, getVSCodeAPI } from "./getVscodeApi"
 
 
 // a "thread" means a chat message history
 type ConfigForThreadsValueType = {
-	readonly allThreads: ChatThreads | null,
-	readonly currentThread: ChatThreads[string] | null;
+	readonly getAllThreads: () => ChatThreads;
+	readonly getCurrentThread: () => ChatThreads[string] | null;
 	addMessageToHistory: (message: ChatMessage) => void;
 	switchToThread: (threadId: string) => void;
 	startNewThread: () => void;
@@ -14,11 +14,15 @@ type ConfigForThreadsValueType = {
 
 const ThreadsContext = createContext<ConfigForThreadsValueType>(undefined as unknown as ConfigForThreadsValueType)
 
-const createNewThread = () => ({
-	id: new Date().getTime().toString(),
-	createdAt: new Date().toISOString(),
-	messages: [],
-})
+const createNewThread = () => {
+	const now = new Date().toISOString()
+	return {
+		id: new Date().getTime().toString(),
+		createdAt: now,
+		lastModified: now,
+		messages: [],
+	}
+}
 
 
 // const [stateRef, setState] = useInstantState(initVal)
@@ -35,8 +39,8 @@ const useInstantState = <T,>(initVal: T) => {
 
 
 export function ThreadsProvider({ children }: { children: ReactNode }) {
-	const [allThreads, setAllThreads] = useInstantState<ChatThreads>({})
-	const [currentThreadId, setCurrentThreadId] = useInstantState<string | null>(null)
+	const [allThreadsRef, setAllThreads] = useInstantState<ChatThreads>({})
+	const [currentThreadIdRef, setCurrentThreadId] = useInstantState<string | null>(null)
 
 	// this loads allThreads in on mount
 	useEffect(() => {
@@ -51,12 +55,12 @@ export function ThreadsProvider({ children }: { children: ReactNode }) {
 	return (
 		<ThreadsContext.Provider
 			value={{
-				allThreads: allThreads.current,
-				currentThread: currentThreadId.current === null || allThreads.current === null ? null : allThreads.current[currentThreadId.current],
+				getAllThreads: () => allThreadsRef.current ?? {},
+				getCurrentThread: () => currentThreadIdRef.current ? allThreadsRef.current?.[currentThreadIdRef.current] ?? null : null,
 				addMessageToHistory: (message: ChatMessage) => {
 					let currentThread: ChatThreads[string]
-					if (!(currentThreadId.current === null || allThreads.current === null)) {
-						currentThread = allThreads.current[currentThreadId.current]
+					if (!(currentThreadIdRef.current === null || allThreadsRef.current === null)) {
+						currentThread = allThreadsRef.current[currentThreadIdRef.current]
 					}
 					else {
 						currentThread = createNewThread()
@@ -64,9 +68,10 @@ export function ThreadsProvider({ children }: { children: ReactNode }) {
 					}
 
 					setAllThreads({
-						...allThreads.current,
+						...allThreadsRef.current,
 						[currentThread.id]: {
 							...currentThread,
+							lastModified: new Date().toISOString(),
 							messages: [...currentThread.messages, message],
 						}
 					})
@@ -79,7 +84,7 @@ export function ThreadsProvider({ children }: { children: ReactNode }) {
 				startNewThread: () => {
 					const newThread = createNewThread()
 					setAllThreads({
-						...allThreads.current,
+						...allThreadsRef.current,
 						[newThread.id]: newThread
 					})
 					setCurrentThreadId(newThread.id)

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

@@ -1,5 +1,5 @@
 import { useEffect } from "react";
-import { MessageFromSidebar, MessageToSidebar, } from "../shared_types";
+import { MessageFromSidebar, MessageToSidebar, } from "../../common/shared_types";
 import { v4 as uuidv4 } from 'uuid';
 
 
@@ -8,23 +8,27 @@ type Command = MessageToSidebar['type']
 // messageType -> res[]
 const onetimeCallbacks: { [C in Command]: ((res: any) => void)[] } = {
 	"ctrl+l": [],
+	"ctrl+k": [],
 	"files": [],
 	"partialVoidConfig": [],
 	"startNewThread": [],
 	"allThreads": [],
 	"toggleThreadSelector": [],
 	"toggleSettings": [],
+	"deviceId": [],
 }
 
 // messageType -> id -> res
 const callbacks: { [C in Command]: { [id: string]: ((res: any) => void) } } = {
 	"ctrl+l": {},
+	"ctrl+k": {},
 	"files": {},
 	"partialVoidConfig": {},
 	"startNewThread": {},
 	"allThreads": {},
 	"toggleThreadSelector": {},
 	"toggleSettings": {},
+	"deviceId": {}
 }
 
 

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

@@ -0,0 +1,72 @@
+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)
+
+	let props = rootElement.getAttribute("data-void-props")
+	let propsObj: object | null = null
+	if (props !== null) {
+		propsObj = JSON.parse(decodeURIComponent(props))
+	}
+
+	const content = (<>
+		<ListenersAndTracking />
+
+		<PropsProvider props={propsObj}>
+			<ThreadsProvider>
+				<ConfigProvider>
+					{children}
+				</ConfigProvider>
+			</ThreadsProvider>
+		</PropsProvider>
+	</>)
+
+	const root = ReactDOM.createRoot(rootElement)
+	root.render(content);
+
+}

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

@@ -0,0 +1,20 @@
+import posthog from 'posthog-js'
+
+
+export const identifyUser = (id: string) => {
+	posthog.identify(id)
+}
+
+export const captureEvent = (eventId: string, properties: object) => {
+	posthog.capture(eventId, properties)
+}
+
+export const initPosthog = () => {
+	// We send absolutely no code to the server. We only track usage metrics like button clicks, etc. This might change and we might eventually add an opt-in or opt-out.
+	posthog.init('phc_UanIdujHiLp55BkUTjB1AuBXcasVkdqRwgnwRlWESH2',
+		{
+			api_host: 'https://us.i.posthog.com',
+			person_profiles: 'identified_only' // we only track events from identified users. We identify them in Sidebar
+		}
+	)
+}

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

@@ -0,0 +1,20 @@
+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')
+	})
+
+	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/sidebar/Sidebar.tsx

@@ -1,70 +1,65 @@
 import React, { useState, useEffect, useRef, useCallback, FormEvent } from "react"
-import { CodeSelection, ChatMessage, MessageToSidebar } from "../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 { useThreads } from "./contextForThreads";
 import { SidebarChat } from "./SidebarChat";
-import { SidebarSettings } from './SidebarSettings';
-
+import { SidebarSettings } from "./SidebarSettings";
+import { identifyUser } from "../common/posthog";
 
 
 const Sidebar = () => {
+
+	const chatInputRef = useRef<HTMLTextAreaElement | null>(null)
+
 	const [tab, setTab] = useState<'threadSelector' | 'chat' | 'settings'>('chat')
 
 	// if they pressed the + to add a new chat
 	useOnVSCodeMessage('startNewThread', (m) => {
-		setTab('chat')
+		setTab('chat');
+		chatInputRef.current?.focus();
+	})
+
+	// ctrl+l should switch back to chat
+	useOnVSCodeMessage('ctrl+l', (m) => {
+		setTab('chat');
+		chatInputRef.current?.focus();
 	})
 
 	// if they toggled thread selector
 	useOnVSCodeMessage('toggleThreadSelector', (m) => {
-		if (tab === 'threadSelector')
+		if (tab === 'threadSelector') {
 			setTab('chat')
-		else
+			chatInputRef.current?.blur();
+		} else
 			setTab('threadSelector')
 	})
 
 	// if they toggled settings
 	useOnVSCodeMessage('toggleSettings', (m) => {
-		if (tab === 'settings')
+		if (tab === 'settings') {
 			setTab('chat')
-		else
+			chatInputRef.current?.blur();
+		} else
 			setTab('settings')
 	})
 
-
-	// Receive messages from the VSCode extension
-	useEffect(() => {
-		const listener = (event: MessageEvent) => {
-			const m = event.data as MessageToSidebar;
-			onMessageFromVSCode(m)
-		}
-		window.addEventListener('message', listener);
-		return () => { window.removeEventListener('message', listener) }
-	}, [])
-
-
-
 	return <>
 		<div className={`flex flex-col h-screen w-full`}>
 
-			<div className={`mb-2 max-h-[30vh] overflow-y-auto ${tab !== 'threadSelector' ? 'hidden' : ''}`}>
+			<div className={`mb-2 h-[30vh] ${tab !== 'threadSelector' ? 'hidden' : ''}`}>
 				<SidebarThreadSelector onClose={() => setTab('chat')} />
 			</div>
 
 			<div className={`${tab !== 'chat' && tab !== 'threadSelector' ? 'hidden' : ''}`}>
-				<SidebarChat />
+				<SidebarChat chatInputRef={chatInputRef} />
 			</div>
 
 			<div className={`${tab !== 'settings' ? 'hidden' : ''}`}>
 				<SidebarSettings />
 			</div>
 
-
-
 		</div>
-
 	</>
 
 }

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

@@ -4,13 +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 { SelectedFiles } from "./components/SelectedFiles";
-import { File, ChatMessage, CodeSelection } from "../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 { 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";
 
 
 
@@ -62,6 +63,55 @@ Please edit the selected code following these instructions:
 	return str;
 };
 
+
+
+
+
+const getBasename = (pathStr: string) => {
+	// "unixify" path
+	pathStr = pathStr.replace(/[/\\]+/g, "/") // replace any / or \ or \\ with /
+	const parts = pathStr.split("/") // split on /
+	return parts[parts.length - 1]
+}
+
+export const SelectedFiles = ({ files, setFiles, }: { files: vscode.Uri[], setFiles: null | ((files: vscode.Uri[]) => void) }) => {
+	return (
+		files.length !== 0 && (
+			<div className="flex flex-wrap -mx-1 -mb-1">
+				{files.map((filename, i) => (
+					<button
+						key={filename.path}
+						disabled={!setFiles}
+						className={`btn btn-secondary btn-sm border border-vscode-input-border rounded flex items-center space-x-2 mx-1 mb-1 disabled:cursor-default`}
+						type="button"
+						onClick={() => setFiles?.([...files.slice(0, i), ...files.slice(i + 1, Infinity)])}
+					>
+						<span>{getBasename(filename.fsPath)}</span>
+
+						{/* X button */}
+						{!!setFiles && <span className="">
+							<svg
+								xmlns="http://www.w3.org/2000/svg"
+								fill="none"
+								viewBox="0 0 24 24"
+								stroke="currentColor"
+								className="size-4"
+							>
+								<path
+									strokeLinecap="round"
+									strokeLinejoin="round"
+									d="M6 18 18 6M6 6l12 12"
+								/>
+							</svg>
+						</span>}
+					</button>
+				))}
+			</div>
+		)
+	)
+}
+
+
 const ChatBubble = ({ chatMessage }: { chatMessage: ChatMessage }) => {
 
 	const role = chatMessage.role
@@ -75,16 +125,17 @@ const ChatBubble = ({ chatMessage }: { chatMessage: ChatMessage }) => {
 	if (role === 'user') {
 		chatbubbleContents = <>
 			<SelectedFiles files={chatMessage.files} setFiles={null} />
-			{chatMessage.selection?.selectionStr && <BlockCode text={chatMessage.selection.selectionStr} hideToolbar />}
+			{chatMessage.selection?.selectionStr && <BlockCode
+				text={chatMessage.selection.selectionStr}
+				buttonsOnHover={null}
+			/>}
 			{children}
 		</>
 	}
 	else if (role === 'assistant') {
-
 		chatbubbleContents = <MarkdownRender string={children} /> // sectionsHTML
 	}
 
-
 	return <div className={`${role === 'user' ? 'text-right' : 'text-left'}`}>
 		<div className={`inline-block p-2 rounded-lg space-y-2 ${role === 'user' ? 'bg-vscode-input-bg text-vscode-input-fg' : ''} max-w-full`}>
 			{chatbubbleContents}
@@ -93,7 +144,8 @@ const ChatBubble = ({ chatMessage }: { chatMessage: ChatMessage }) => {
 }
 
 
-export const SidebarChat = () => {
+
+export const SidebarChat = ({ chatInputRef }: { chatInputRef: React.RefObject<HTMLTextAreaElement> }) => {
 
 
 	// state of current message
@@ -109,11 +161,30 @@ export const SidebarChat = () => {
 	const [latestError, setLatestError] = useState('')
 
 	// higher level state
-	const { allThreads, currentThread, addMessageToHistory, startNewThread, switchToThread } = useThreads()
+	const { getAllThreads, getCurrentThread, addMessageToHistory, startNewThread, switchToThread } = useThreads()
+
 	const { voidConfig } = useVoidConfig()
 
+
+
+	// only captures number of messages and message "shape", no actual code, instructions, prompts, etc
+	const captureChatEvent = useCallback((eventId: string, extras?: object) => {
+		const whichApi = voidConfig.default['whichApi']
+		const messages = getCurrentThread()?.messages
+
+		captureEvent(eventId, {
+			whichApi: whichApi,
+			numMessages: messages?.length,
+			messagesShape: messages?.map(msg => ({ role: msg.role, length: msg.displayContent?.length })),
+			version: '2024-10-19',
+			...extras,
+		})
+	}, [getCurrentThread, voidConfig.default])
+
+
 	// if they pressed the + to add a new chat
 	useOnVSCodeMessage('startNewThread', (m) => {
+		const allThreads = getAllThreads()
 		// find a thread with 0 messages and switch to it
 		for (let threadId in allThreads) {
 			if (allThreads[threadId].messages.length === 0) {
@@ -136,10 +207,13 @@ export const SidebarChat = () => {
 	})
 
 
+	const isDisabled = !instructions
+
 	const formRef = useRef<HTMLFormElement | null>(null)
 	const onSubmit = async (e: FormEvent<HTMLFormElement>) => {
 
 		e.preventDefault()
+		if (isDisabled) return
 		if (isLoading) return
 
 		setIsLoading(true)
@@ -153,24 +227,33 @@ export const SidebarChat = () => {
 		getVSCodeAPI().postMessage({ type: 'requestFiles', filepaths: files })
 		const relevantFiles = await awaitVSCodeResponse('files')
 
-		// add message to chat history
+		// add system message to chat history
+		const systemPromptElt: ChatMessage = { role: 'system', content: generateDiffInstructions }
+		addMessageToHistory(systemPromptElt)
+
 		const userContent = userInstructionsStr(instructions, relevantFiles.files, selection)
-		// console.log('prompt:\n', content)
 		const newHistoryElt: ChatMessage = { role: 'user', content: userContent, displayContent: instructions, selection, files }
 		addMessageToHistory(newHistoryElt)
 
+		captureChatEvent('Chat - Sending Message', { messageLength: instructions.length })
+		const submit_time = new Date()
+
 		// send message to LLM
-		let { abort } = sendLLMMessage({
-			messages: [...(currentThread?.messages ?? []).map(m => ({ role: m.role, content: m.content })), { role: 'user', content: userContent }],
+		sendLLMMessage({
+			messages: [...(getCurrentThread()?.messages ?? []).map(m => ({ role: m.role, content: m.content })),],
 			onText: (newText, fullText) => setMessageStream(fullText),
 			onFinalMessage: (content) => {
+				captureChatEvent('Chat - Received Full Message', { messageLength: content.length, duration: new Date().getMilliseconds() - submit_time.getMilliseconds() })
+
 				// add assistant's message to chat history, and clear selection
-				const newHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content, }
+				const newHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content }
 				addMessageToHistory(newHistoryElt)
 				setMessageStream('')
 				setIsLoading(false)
 			},
 			onError: (error) => {
+				captureChatEvent('Chat - Error', { error })
+
 				// add assistant's message to chat history, and clear selection
 				let content = messageStream; // just use the current content
 				const newHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content, }
@@ -180,36 +263,35 @@ export const SidebarChat = () => {
 
 				setLatestError(error)
 			},
-			voidConfig: voidConfig
+			voidConfig,
+			abortRef: abortFnRef,
 		})
-		abortFnRef.current = abort
+
 
 	}
 
-	const onStop = useCallback(() => {
+	const onAbort = useCallback(() => {
+
+		captureChatEvent('Chat - Abort', { messageLengthSoFar: messageStream.length })
+
 		// abort claude
 		abortFnRef.current?.()
 
 		// if messageStream was not empty, add it to the history
-		const llmContent = messageStream || '(canceled)'
-		const newHistoryElt: ChatMessage = { role: 'assistant', displayContent: messageStream, content: llmContent }
+		const llmContent = messageStream || '(null)'
+		const newHistoryElt: ChatMessage = { role: 'assistant', content: llmContent, displayContent: messageStream, }
 		addMessageToHistory(newHistoryElt)
 
 		setMessageStream('')
 		setIsLoading(false)
 
-	}, [addMessageToHistory, messageStream])
-
-	//Clear code selection
-	const clearSelection = () => {
-		setSelection(null);
-	};
+	}, [captureChatEvent, messageStream, addMessageToHistory])
 
 
 	return <>
-		<div className="overflow-y-auto overflow-x-hidden space-y-4">
+		<div className="overflow-x-hidden space-y-4">
 			{/* previous messages */}
-			{currentThread !== null && currentThread.messages.map((message, i) =>
+			{getCurrentThread() !== null && getCurrentThread()?.messages.map((message, i) =>
 				<ChatBubble key={i} chatMessage={message} />
 			)}
 			{/* message stream */}
@@ -219,7 +301,6 @@ export const SidebarChat = () => {
 		<div className="shrink-0 py-4">
 			{/* selection */}
 			<div className="text-left">
-
 				<div className="relative">
 					<div className="input">
 						{/* selection */}
@@ -228,16 +309,18 @@ export const SidebarChat = () => {
 							<SelectedFiles files={files} setFiles={setFiles} />
 							{/* selected code */}
 							{!!selection?.selectionStr && (
-								<BlockCode className="rounded bg-vscode-sidebar-bg" text={selection.selectionStr} toolbar={(
-									<button
-										onClick={clearSelection}
-										className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
-									>
-										Remove
-									</button>
-								)} />
+								<BlockCode text={selection.selectionStr}
+									buttonsOnHover={(
+										<button
+											onClick={() => setSelection(null)}
+											className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
+										>
+											Remove
+										</button>
+									)} />
 							)}
 						</div>}
+
 						<form
 							ref={formRef}
 							className="flex flex-row items-center rounded-md p-2"
@@ -245,28 +328,36 @@ export const SidebarChat = () => {
 
 							onSubmit={(e) => {
 								console.log('submit!')
-								e.preventDefault();
 								onSubmit(e)
 							}}>
 							{/* input */}
 
 							<textarea
+								ref={chatInputRef}
 								onChange={(e) => { setInstructions(e.target.value) }}
 								className="w-full p-2 leading-tight resize-none max-h-[50vh] overflow-hidden bg-transparent border-none !outline-none"
 								placeholder="Ctrl+L to select"
 								rows={1}
 								onInput={e => { e.currentTarget.style.height = 'auto'; e.currentTarget.style.height = e.currentTarget.scrollHeight + 'px' }} // Adjust height dynamically
 							/>
-							{/* submit button */}
 							{isLoading ?
+								// stop button
 								<button
-									onClick={onStop}
-									className="btn btn-primary rounded-r-lg max-h-10 p-2"
+									onClick={onAbort}
 									type='button'
-								>Stop</button>
-								: <button
 									className="btn btn-primary font-bold size-8 flex justify-center items-center rounded-full p-2 max-h-10"
-									disabled={!instructions}
+								>
+									<svg
+										className='scale-50'
+										stroke="currentColor" fill="currentColor" strokeWidth="0" viewBox="0 0 24 24" height="24" width="24" xmlns="http://www.w3.org/2000/svg">
+										<path d="M24 24H0V0h24v24z"></path>
+									</svg>
+								</button>
+								:
+								// submit button (up arrow)
+								<button
+									className="btn btn-primary font-bold size-8 flex justify-center items-center rounded-full p-2 max-h-10"
+									disabled={isDisabled}
 									type='submit'
 								>
 									<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
@@ -280,7 +371,10 @@ export const SidebarChat = () => {
 				</div>
 			</div>
 
-			{latestError}
+			{/* error message */}
+			{!latestError ? null : <div>
+				{latestError}
+			</div>}
 		</div>
 	</>
 }

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 }) => {
@@ -9,10 +9,15 @@ const SettingOfFieldAndParam = ({ field, param }: { field: VoidConfigField, para
 
 	const updateState = (newValue: string) => { setConfigParam(field, param, newValue) }
 
-	const resetButton = <button className='btn btn-sm' onClick={() => updateState(defaultVal)}>
+	const resetButton = <button
+		disabled={val === defaultVal}
+		title={val === defaultVal ? 'This is the default value.' : `Revert value to '${defaultVal}'?`}
+		className='group btn btn-sm disabled:opacity-75 disabled:cursor-default'
+		onClick={() => updateState(defaultVal)}
+	>
 		<svg
-			className='size-5'
-			stroke="currentColor" fill="currentColor" strokeWidth="0" viewBox="0 0 16 16" height="200px" width="200px" xmlns="http://www.w3.org/2000/svg"><path fillRule="evenodd" clipRule="evenodd" d="M3.5 2v3.5L4 6h3.5V5H4.979l.941-.941a3.552 3.552 0 1 1 5.023 5.023L5.746 14.28l.72.72 5.198-5.198A4.57 4.57 0 0 0 5.2 3.339l-.7.7V2h-1z"></path>
+			className='size-5 group-disabled:stroke-current group-disabled:fill-current group-hover:stroke-red-600 group-hover:fill-red-600 duration-200'
+			fill="currentColor" strokeWidth="0" viewBox="0 0 16 16" height="200px" width="200px" xmlns="http://www.w3.org/2000/svg"><path fillRule="evenodd" clipRule="evenodd" d="M3.5 2v3.5L4 6h3.5V5H4.979l.941-.941a3.552 3.552 0 1 1 5.023 5.023L5.746 14.28l.72.72 5.198-5.198A4.57 4.57 0 0 0 5.2 3.339l-.7.7V2h-1z"></path>
 		</svg>
 	</button>
 
@@ -64,6 +69,10 @@ export const SidebarSettings = () => {
 					field='default'
 					param='whichApi'
 				/>
+				<SettingOfFieldAndParam
+					field='default'
+					param='maxTokens'
+				/>
 			</div>
 
 			<hr />

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) => {
@@ -12,10 +12,12 @@ const truncate = (s: string) => {
 
 
 export const SidebarThreadSelector = ({ onClose }: { onClose: () => void }) => {
-	const { allThreads, currentThread, switchToThread } = useThreads()
+	const { getAllThreads, getCurrentThread, switchToThread } = useThreads()
+
+	const allThreads = getAllThreads()
 
 	// sorted by most recent to least recent
-	const sortedThreadIds = Object.keys(allThreads ?? {}).sort((threadId1, threadId2) => allThreads![threadId1].createdAt > allThreads![threadId2].createdAt ? -1 : 1)
+	const sortedThreadIds = Object.keys(allThreads ?? {}).sort((threadId1, threadId2) => allThreads![threadId1].lastModified > allThreads![threadId2].lastModified ? 1 : -1)
 
 	return (
 		<div className="flex flex-col gap-y-1">
@@ -62,7 +64,7 @@ export const SidebarThreadSelector = ({ onClose }: { onClose: () => void }) => {
 					return (
 						<button
 							key={pastThread.id}
-							className={`btn btn-sm rounded-sm ${pastThread.id === currentThread?.id ? "btn-primary" : "btn-secondary"}`}
+							className={`btn btn-sm rounded-sm ${pastThread.id === getCurrentThread()?.id ? "btn-primary" : "btn-secondary"}`}
 							onClick={() => switchToThread(pastThread.id)}
 							title={new Date(pastThread.createdAt).toLocaleString()}
 						>

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/BlockCode.tsx

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

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

@@ -1,6 +1,57 @@
-import React, { JSX } from "react"
+import React, { JSX, useCallback, useEffect, useState } from "react"
 import { marked, MarkedToken, Token, TokensList } from "marked"
 import BlockCode from "./BlockCode"
+import { getVSCodeAPI } from "../../common/getVscodeApi"
+
+
+enum CopyButtonState {
+	Copy = "Copy",
+	Copied = "Copied!",
+	Error = "Could not copy",
+}
+
+const COPY_FEEDBACK_TIMEOUT = 1000 // amount of time to say 'Copied!'
+
+const CodeButtonsOnHover = ({ diffRepr: text }: { diffRepr: string }) => {
+	const [copyButtonState, setCopyButtonState] = useState(CopyButtonState.Copy)
+
+	useEffect(() => {
+		if (copyButtonState !== CopyButtonState.Copy) {
+			setTimeout(() => {
+				setCopyButtonState(CopyButtonState.Copy)
+			}, COPY_FEEDBACK_TIMEOUT)
+		}
+	}, [copyButtonState])
+
+	const onCopy = useCallback(() => {
+		navigator.clipboard.writeText(text).then(
+			() => {
+				setCopyButtonState(CopyButtonState.Copied)
+			},
+			() => {
+				setCopyButtonState(CopyButtonState.Error)
+			}
+		)
+	}, [text])
+
+	return <>
+		<button
+			className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
+			onClick={onCopy}
+		>
+			{copyButtonState}
+		</button>
+		<button
+			className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
+			onClick={async () => {
+				getVSCodeAPI().postMessage({ type: "applyChanges", diffRepr: text })
+			}}
+		>
+			Apply
+		</button>
+	</>
+}
+
 
 const RenderToken = ({ token, nested = false }: { token: Token | string, nested?: boolean }): JSX.Element => {
 
@@ -12,7 +63,11 @@ const RenderToken = ({ token, nested = false }: { token: Token | string, nested?
 	}
 
 	if (t.type === "code") {
-		return <BlockCode text={t.text} language={t.lang} />
+		return <BlockCode
+			text={t.text}
+			language={t.lang}
+			buttonsOnHover={<CodeButtonsOnHover diffRepr={t.text} />}
+		/>
 	}
 
 	if (t.type === "heading") {

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;
@@ -29,6 +31,7 @@ html {
 		}
 	}
 
+	/* add transparency when disabled */
 	&:disabled {
 		@apply opacity-75 cursor-not-allowed;
 	}

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: {

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

@@ -823,7 +823,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 				return extHostWebviewPanels.createWebviewPanel(extension, viewType, title, showOptions, options);
 			},
 			createWebviewTextEditorInset(editor: vscode.TextEditor, line: number, height: number, options?: vscode.WebviewOptions): vscode.WebviewEditorInset {
-				checkProposedApiEnabled(extension, 'editorInsets');
+				// checkProposedApiEnabled(extension, 'editorInsets'); // Void commented this out
 				return extHostEditorInsets.createWebviewEditorInset(editor, line, height, options, extension);
 			},
 			createTerminal(nameOrOptions?: vscode.TerminalOptions | vscode.ExtensionTerminalOptions | string, shellPath?: string, shellArgs?: readonly string[] | string): vscode.Terminal {

src/vscode-dts/vscode.d.ts

@@ -9479,7 +9479,6 @@ declare module 'vscode' {
 		 */
 		readonly extensionHostPort: number;
 	}
-
 	/**
 	 * Content settings for a webview.
 	 */