add throttling

extensions/void/src/DiffProvider.ts

@@ -1,4 +1,448 @@
 import * as vscode from 'vscode';
+import { findDiffs } from './findDiffs';
+import { Diff, DiffArea, BaseDiff, } from './common/shared_types';
+import { readFileContentOfUri } from './common/readFileContentOfUri';
+import { throttle } from 'lodash';
+
+
+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({
@@ -13,8 +457,6 @@ export class DiffProvider {
 
 	originalCodeOfDocument: { [docUri: string]: string }
 
-
-
 	diffsOfDocument: {
 		[docUri: string]: {
 			startLine,
@@ -113,3 +555,6 @@ export class DiffProvider {
 
 
 }
+
+
+*/

extensions/void/src/DisplayChangesProvider.ts

@@ -1,315 +0,0 @@
-import * as vscode from 'vscode';
-import { findDiffs } from './findDiffs';
-import { Diff, BaseDiffArea, BaseDiff, DiffArea } from './common/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 {
-
-	private _diffAreasOfDocument: { [docUriStr: string]: DiffArea[] } = {}
-	private _diffsOfDocument: { [docUriStr: string]: Diff[] } = {}
-
-	private _diffareaidPool = 0
-	private _diffidPool = 0
-	private _weAreEditing: boolean = false
-
-	private _onDidChangeDiffsEvent: vscode.EventEmitter<void> = new vscode.EventEmitter<void>(); // signals a UI refresh on .fire() events
-
-	// declared by us, registered with vscode.languages.registerCodeLensProvider()
-	constructor() {
-		console.log('Creating DisplayChangesProvider')
-
-		// update diffs whenever the event fires
-		this._onDidChangeDiffsEvent.event(() => {
-			const editor = vscode.window.activeTextEditor
-			if (!editor) return
-
-			let document = editor.document
-			const docUriStr = document.uri.toString()
-			return this._diffsOfDocument[docUriStr]?.flatMap(diff => diff.lenses) ?? []
-		})
-
-		// this acts as a useEffect. Every time text changes, run this
-		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)
-
-			// add the diffs to `this._diffsOfDocument[docUriStr]`
-			this.addDiffs(editor.document.uri, diffs, diffArea)
-
-			// // print diffs
-			console.log('!CodeBefore:', JSON.stringify(diffArea.originalCode))
-			console.log('!CodeAfter:', JSON.stringify(currentCode))
-			console.log('DiffRepr: ', diffs.map(diff => diff.code).join('\n'))
-			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._onDidChangeDiffsEvent.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/common/ctrlK.ts

@@ -0,0 +1,101 @@
+import * as vscode from 'vscode';
+import { AbortRef, OnFinalMessage, OnText, sendLLMMessage } from "./sendLLMMessage"
+import { VoidConfig } from '../sidebar/contextForConfig';
+import { findDiffs } from '../findDiffs';
+import { searchDiffChunkInstructions, writeFileWithDiffInstructions } from './systemPrompts';
+import { throttle } from 'lodash';
+import { readFileContentOfUri } from './readFileContentOfUri';
+
+type Res<T> = ((value: T) => void)
+
+const THRTOTLE_TIME = 100 // minimum time between edits
+const LINES_PER_CHUNK = 20 // number of lines to search at a time
+
+const applyCtrlLChangesToFile = throttle(
+	({ fileUri, newCurrentLine, oldCurrentLine, fullCompletedStr, oldFileStr, debug }: { fileUri: vscode.Uri, newCurrentLine: number, oldCurrentLine: number, fullCompletedStr: string, oldFileStr: string, debug?: string }) => {
+
+		// write the change to the file
+		const WRITE_TO_FILE = (
+			fullCompletedStr.split('\n').slice(0, newCurrentLine + 1).join('\n')  // newFile[:newCurrentLine+1]
+			+ oldFileStr.split('\n').slice(oldCurrentLine + 1).join('\n')	// oldFile[oldCurrentLine+1:]
+		)
+		const workspaceEdit = new vscode.WorkspaceEdit()
+		workspaceEdit.replace(fileUri, new vscode.Range(0, 0, Number.MAX_SAFE_INTEGER, 0), WRITE_TO_FILE)
+		vscode.workspace.applyEdit(workspaceEdit)
+
+		// highlight the `newCurrentLine` in white
+		// highlight the remaining part of the file in gray
+
+	},
+	THRTOTLE_TIME, { trailing: true }
+)
+
+
+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/ctrlL.ts

@@ -1,49 +1,22 @@
 import * as vscode from 'vscode';
-import { OnFinalMessage, OnText, sendLLMMessage, SetAbort } from "./sendLLMMessage"
+import { AbortRef, OnFinalMessage, OnText, sendLLMMessage } from "./sendLLMMessage"
 import { VoidConfig } from '../sidebar/contextForConfig';
 import { findDiffs } from '../findDiffs';
 import { searchDiffChunkInstructions, writeFileWithDiffInstructions } from './systemPrompts';
 import { throttle } from 'lodash';
+import { readFileContentOfUri } from './readFileContentOfUri';
+import { DiffProvider } from '../DiffProvider';
+import { DiffArea } from './shared_types';
 
-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
-}
-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 }) => {
+// const THRTOTLE_TIME = 100 // minimum time between edits
+// 	throttle(
+// 	THRTOTLE_TIME, { trailing: true }
+// )
 
-		console.log('DEBUG: ', debug)
-		console.log('oldNext: ', oldCurrentLine)
-		console.log('newNext: ', newCurrentLine)
-		console.log('WRITE_TO_FILE1: ', fullCompletedStr.split('\n').slice(0, newCurrentLine + 1).join('\n'))
-		console.log('WRITE_TO_FILE2: ', oldFileStr.split('\n').slice(oldCurrentLine + 1).join('\n'))
-
-		// 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 }
-)
-
-
-// `next` is the line after the completed text
-// `oldNext` is the same line but in the original file
-type CompetedReturn = { isFinished: true, next?: undefined, oldNext?: undefined, } | { isFinished?: undefined, next: number, oldNext: number, }
-const generateFileUsingDiffUntilMatchup = ({ fileUri, oldFileStr, completedStr, oldNext, next, diffStr, voidConfig, setAbort }: { fileUri: vscode.Uri, oldFileStr: string, completedStr: string, oldNext: number, next: number, diffStr: string, voidConfig: VoidConfig, setAbort: SetAbort }) => {
+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
 
@@ -54,7 +27,7 @@ ${oldFileStr}
 
 DIFF
 \`\`\`
-${diffStr}
+${diffRepr}
 \`\`\`
 
 INSTRUCTIONS
@@ -66,67 +39,43 @@ ${completedStr}
 \`\`\`
 `
 	// create a promise that can be awaited
-	const promise = new Promise<CompetedReturn>((resolve, reject) => {
-
-		// get the abort method
-		let _abort = () => { }
-		let did_abort = false
+	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: (tokenStr, deltaStr) => {
+			onText: (newText, fullText) => {
+				const fullCompletedStr = completedStr + fullText
 
-				if (did_abort) return;
-
-				const fullCompletedStr = completedStr + deltaStr
-
-				// diff `originalFileStr` and `newFileStr`
-				const diffs = findDiffs(oldFileStr, fullCompletedStr)
-				const lastDiff = diffs[diffs.length - 1]
-				const oldLineAfterLastDiff = lastDiff.originalEndLine + 1
-				const newLineAfterLastDiff = lastDiff.endLine + 1
-
-				// check if we've generated a diff
-				const didGenerateDiff = newLineAfterLastDiff > next
-
-				// get the line we are currently generating `newCurrentLine`; make sure it never goes past the last diff we've generated
-				// - if `deltaStr` contains a diff, then _next = newLineAfterLastDiff - 1
-				// - if it does not contain a diff, then _next = next + deltaStr.split('\n').length - 1
-				const newCurrentLine = didGenerateDiff ? newLineAfterLastDiff - 1 : next + deltaStr.split('\n').length - 1
-				const oldCurrentLine = didGenerateDiff ? oldLineAfterLastDiff - 1 : oldNext + (newCurrentLine - next)
-
-				// 1. Apply the changes and modify highlighting
-
-				applyCtrlLChangesToFile({ fileUri, newCurrentLine, oldCurrentLine, fullCompletedStr, oldFileStr })
-
-				// 2. Check for early stopping
-				// the conditions for early stopping are:
-				// - we have generated a diff
-				// - there is matchup with the original file after the diff
-				const isMatchupAfterDiff = fullCompletedStr.split('\n').slice(newLineAfterLastDiff).join('\n').length > NUM_MATCHUP_TOKENS
-				if (didGenerateDiff && isMatchupAfterDiff) {
-
-					// resolve the promise
-					resolve({ next: newCurrentLine + 1, oldNext: oldCurrentLine + 1, });
-
-					// abort the LLM call
-					_abort()
-					did_abort = true
-
-				} else {
+				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: (deltaStr) => {
-
-				const newCompletedStr = completedStr + deltaStr
-
-				applyCtrlLChangesToFile({ fileUri, newCurrentLine: Number.MAX_SAFE_INTEGER, oldCurrentLine: Number.MAX_SAFE_INTEGER, fullCompletedStr: newCompletedStr, oldFileStr, debug: 'FINAL' })
 
+			onFinalMessage: (fullText) => {
+				const newCompletedStr = completedStr + fullText
+				diffProvider.updateStream(docUri.toString(), diffArea, newCompletedStr)
 				resolve({ isFinished: true });
 			},
 			onError: (e) => {
@@ -134,23 +83,17 @@ ${completedStr}
 				console.error('Error rewriting file with diff', e);
 			},
 			voidConfig,
-			setAbort: (a) => { setAbort(a); _abort = a; },
+			abortRef,
 		})
 	})
-
-
-
-
-	return promise
-
 }
 
 
-const shouldApplyDiffFn = ({ diffStr, fileStr, speculationStr, voidConfig, setAbort }: { diffStr: string, fileStr: string, speculationStr: string, voidConfig: VoidConfig, setAbort: SetAbort }) => {
+const shouldApplyDiff = ({ diffRepr, oldFileStr: fileStr, speculationStr, voidConfig, abortRef }: { diffRepr: string, oldFileStr: string, speculationStr: string, voidConfig: VoidConfig, abortRef: AbortRef }) => {
 
 	const promptContent = `DIFF
 \`\`\`
-${diffStr}
+${diffRepr}
 \`\`\`
 
 FILES
@@ -167,7 +110,7 @@ Return \`true\` if ANY part of the chunk should be modified, and \`false\` if it
 `
 
 	// create new promise
-	const promise = new Promise<boolean>((resolve, reject) => {
+	return new Promise<boolean>((resolve, reject) => {
 		// send message to LLM
 		sendLLMMessage({
 			messages: [{ role: 'system', content: searchDiffChunkInstructions, }, { role: 'user', content: promptContent, }],
@@ -186,12 +129,10 @@ Return \`true\` if ANY part of the chunk should be modified, and \`false\` if it
 			},
 			onText: () => { },
 			voidConfig,
-			setAbort,
+			abortRef,
 		})
-	})
 
-	// return the promise
-	return promise
+	})
 
 }
 
@@ -199,57 +140,46 @@ Return \`true\` if ANY part of the chunk should be modified, and \`false\` if it
 
 // lazily applies the diff to the file
 // we chunk the text in the file, and ask an LLM whether it should edit each chunk
-const applyDiffLazily = async ({ fileUri, oldFileStr, diffStr, voidConfig, setAbort }: { fileUri: vscode.Uri, oldFileStr: string, diffStr: string, voidConfig: VoidConfig, setAbort: SetAbort }) => {
+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 next = 0
-	let oldNext = 0
+	let speculativeIndex = 0
+	let writtenTextSoFar: string[] = []
 
-	while (next < oldFileStr.split('\n').length) {
+	while (speculativeIndex < oldFileStr.split('\n').length) {
 
-		console.log('next line: ', next)
-
-		// get the chunk
-		const chunkStr = oldFileStr.split('\n').slice(next, next + LINES_PER_CHUNK).join('\n')
+		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 shouldApplyDiffFn({ fileStr: oldFileStr, speculationStr: chunkStr, diffStr, voidConfig, setAbort })
-
-		const __end = new Date().getTime()
-
-		if (!shouldApplyDiff) { // should not change the chunk
-			console.log('KEEP CHUNK time: ', __end - __start)
-
-			next += LINES_PER_CHUNK
-			oldNext += LINES_PER_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)
-		// make vscode read uri = 'asdasd'
+		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()
 
-		const ___start = new Date().getTime()
-
-
-		const completedStr = (await readFileContentOfUri(fileUri)).split('\n').slice(0, next).join('\n');
-		const result = await generateFileUsingDiffUntilMatchup({ fileUri, oldFileStr, completedStr, oldNext, next, diffStr, voidConfig, setAbort, })
-
-		const ___end = new Date().getTime()
-
-		console.log('EDIT CHUNK time: ', ___end - ___start);
+		console.log('EDIT CHUNK time: ', END2 - START2);
 
 		// if we are finished, stop the loop
 		if (result.isFinished) {
 			break;
 		}
 
-		next = result.next
-		oldNext = result.oldNext
+		// TODO
+		// speculativeIndex = result.speculativeIndex
 
 	}
 
@@ -258,4 +188,4 @@ const applyDiffLazily = async ({ fileUri, oldFileStr, diffStr, voidConfig, setAb
 
 
 
-export { applyDiffLazily }
+export { applyDiffLazily }

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

@@ -3,15 +3,12 @@ import OpenAI from 'openai';
 import { Ollama } from 'ollama/browser'
 import { VoidConfig } from '../sidebar/contextForConfig';
 
-
-
+export type AbortRef = { current: (() => void) | null }
 
 export type OnText = (newText: string, fullText: string) => void
 
 export type OnFinalMessage = (input: string) => void
 
-export type SetAbort = (abort: () => void) => void
-
 export type LLMMessageAnthropic = {
 	role: 'user' | 'assistant',
 	content: string,
@@ -28,25 +25,23 @@ type SendLLMMessageFnTypeInternal = (params: {
 	onFinalMessage: OnFinalMessage,
 	onError: (error: string) => void,
 	voidConfig: VoidConfig,
-	setAbort: SetAbort,
+	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,
-	setAbort: SetAbort,
-
-})
-	=> void
+	abortRef: AbortRef,
+}) => void
 
 
 
 
 // Anthropic
-const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, setAbort }) => {
+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"]
 
@@ -97,21 +92,21 @@ const sendAnthropicMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFi
 		did_abort = true
 		stream.controller.abort() // TODO need to test this to make sure it works, it might throw an error
 	}
-	setAbort(abort)
 
+	return { abort }
 };
 
 
 
 
 // OpenAI, OpenRouter, OpenAICompatible
-const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, setAbort }) => {
+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;
 	};
 
@@ -144,7 +139,7 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 	openai.chat.completions
 		.create(options)
 		.then(async response => {
-			abort = () => {
+			abortRef.current = () => {
 				// response.controller.abort()
 				didAbort = true;
 			}
@@ -172,18 +167,17 @@ const sendOpenAIMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinal
 			}
 		})
 
-	setAbort(abort)
 };
 
 
 // Ollama
-export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFinalMessage, onError, voidConfig, setAbort }) => {
+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;
 	};
 
@@ -196,8 +190,8 @@ export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText,
 		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
@@ -215,7 +209,6 @@ export const sendOllamaMsg: SendLLMMessageFnTypeInternal = ({ messages, onText,
 			onError(error)
 		})
 
-	setAbort(abort);
 };
 
 
@@ -224,13 +217,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, setAbort }) => {
+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', {
@@ -285,12 +280,11 @@ const sendGreptileMsg: SendLLMMessageFnTypeInternal = ({ messages, onText, onFin
 			onError(e)
 		});
 
-	setAbort(abort)
 }
 
 
 
-export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText, onFinalMessage, onError, voidConfig, setAbort }) => {
+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)
@@ -298,15 +292,15 @@ export const sendLLMMessage: SendLLMMessageFnTypeExternal = ({ messages, onText,
 
 	switch (voidConfig.default.whichApi) {
 		case 'anthropic':
-			return sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig, setAbort });
+			return sendAnthropicMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'openAI':
 		case 'openRouter':
 		case 'openAICompatible':
-			return sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig, setAbort });
+			return sendOpenAIMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'ollama':
-			return sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig, setAbort });
+			return sendOllamaMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		case 'greptile':
-			return sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig, setAbort });
+			return sendGreptileMsg({ messages, onText, onFinalMessage, onError, voidConfig, abortRef });
 		default:
 			onError(`Error: whichApi was ${voidConfig.default.whichApi}, which is not recognized!`)
 	}

extensions/void/src/common/shared_types.ts

@@ -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 original file, inclusive
-	insertedRange: vscode.Range;
-	deletedCode: string; // relative to the new file, inclusive
-	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
@@ -53,7 +50,7 @@ type MessageToSidebar = (
 
 // 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 }
@@ -92,8 +89,8 @@ type ChatMessage =
 	}
 
 export {
-	BaseDiff, BaseDiffArea,
-	Diff, DiffArea,
+	BaseDiff, Diff,
+	DiffArea,
 	CodeSelection,
 	File,
 	MessageFromSidebar,

extensions/void/src/extension.ts

@@ -1,12 +1,12 @@
 import * as vscode from 'vscode';
-import { ApprovalCodeLensProvider } from './ApprovalCodeLensProvider';
-import { ChatThreads, MessageFromSidebar, MessageToSidebar } from './common/shared_types';
+import { DiffProvider } from './DiffProvider';
+import { DiffArea, ChatThreads, MessageFromSidebar, MessageToSidebar } from './common/shared_types';
 import { SidebarWebviewProvider } from './SidebarWebviewProvider';
 import { v4 as uuidv4 } from 'uuid'
 import { applyDiffLazily } from './common/ctrlL';
 import { getVoidConfig } from './sidebar/contextForConfig';
-import { DiffProvider } from './DiffProvider';
-// import { getVoidConfig } from './sidebar/contextForConfig';
+import { readFileContentOfUri } from './common/readFileContentOfUri';
+import { AbortRef } from './common/sendLLMMessage';
 
 // this comes from vscode.proposed.editorInsets.d.ts
 declare module 'vscode' {
@@ -23,13 +23,6 @@ declare module 'vscode' {
 	}
 }
 
-
-
-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
-}
-
 const roundRangeToLines = (selection: vscode.Selection) => {
 	return new vscode.Range(selection.start.line, 0, selection.end.line, Number.MAX_SAFE_INTEGER)
 }
@@ -50,6 +43,15 @@ export function activate(context: vscode.ExtensionContext) {
 			const editor = vscode.window.activeTextEditor
 			if (!editor) return
 
+
+			// const inset = vscode.window.createWebviewTextEditorInset(editor, 10, 10, {})
+			// inset.webview.html = `
+			// <html>
+			// 	<body style="pointer-events:none;">Hello World!</body>
+			// </html>
+			// `;
+
+
 			// show the sidebar
 			vscode.commands.executeCommand('workbench.view.extension.voidViewContainer');
 			// vscode.commands.executeCommand('vscode.moveViewToPanel', CustomViewProvider.viewId); // move to aux bar
@@ -89,16 +91,16 @@ export function activate(context: vscode.ExtensionContext) {
 		})
 	);
 
-	// 3. Show an approve/reject
-	const displayChangesProvider = new DiffProvider();
-	// context.subscriptions.push(vscode.languages.registerCodeLensProvider('*', displayChangesProvider));
+	// 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) => {
-		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
@@ -119,6 +121,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
@@ -137,41 +141,21 @@ export function activate(context: vscode.ExtensionContext) {
 						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))
 
-					// // create an area to show diffs
-					// const diffArea = {
-					// 	startLine: 0, // in ctrl+L the start and end lines are the full document
-					// 	endLine: editor.document.lineCount,
-					// 	originalStartLine: 0,
-					// 	originalEndLine: editor.document.lineCount,
-					// 	originalCode: await readFileContentOfUri(editor.document.uri),
-					// }
-					// displayChangesProvider.addDiffArea(editor.document.uri, diffArea)
-
-
-					// write new code `m.code` to the document
-					// TODO update like this:
-					// this._weAreEditing = true
-					// await vscode.workspace.applyEdit(workspaceEdit)
-					// await vscode.workspace.save(docUri)
-					// this._weAreEditing = false
-					const fileUri = editor.document.uri
-					const fileStr = await readFileContentOfUri(fileUri)
+					const docUri = editor.document.uri
+					const fileStr = await readFileContentOfUri(docUri)
 					const voidConfig = getVoidConfig(context.globalState.get('partialVoidConfig') ?? {})
 
-					let abort = () => { } // TODO this is unused
-
-					// apply the change
-					applyDiffLazily({ fileUri, oldFileStr: fileStr, diffStr: m.code, voidConfig, setAbort: (a) => { abort = a } })
-
-					// set the file equal to the change
-					// 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.refreshLenses(editor, editor.document.uri.toString())
-
+					await applyDiffLazily({ docUri, oldFileStr: fileStr, diffRepr: m.diffRepr, voidConfig, diffProvider, diffArea, abortRef: abortApplyRef })
 				}
 				else if (m.type === 'getPartialVoidConfig') {
 					const partialVoidConfig = context.globalState.get('partialVoidConfig') ?? {}

extensions/void/src/findDiffs.ts

@@ -1,19 +1,31 @@
 
-// import { diffLines, Change } from 'diff';
+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
-	startLine: number;
-	startCol: number;
-	endLine: number;
-	endCol: number;
+	newRange: Range;
 
 	// start/end of original file
-	originalStartLine: number,
-	originalStartCol: number,
-	originalEndLine: number,
-	originalEndCol: number,
+	originalRange: Range;
 	type: 'insertion' | 'deletion' | 'edit',
 	originalContent: string, // original content (originalfile[originalStart...originalEnd])
 	newContent: string,
@@ -33,7 +45,7 @@ export function findDiffs(oldStr: string, newStr: string) {
 	let oldStrLines = oldStr.split('\n')
 	let newStrLines = newStr.split('\n')
 
-	const replacements: SuggestedEdit[] = []
+	const replacements: BaseDiff[] = []
 	for (let line of lineByLineChanges) {
 
 		// no change on this line
@@ -76,11 +88,13 @@ export function findDiffs(oldStr: string, newStr: string) {
 					originalEndCol = 0
 				}
 
-				const replacement: SuggestedEdit = {
+				const replacement: BaseDiff = {
 					type,
-					startLine, startCol, endLine, endCol, newContent,
-					originalStartLine, originalStartCol, originalEndLine, originalEndCol, originalContent
-				} as SuggestedEdit
+					range: new Range(startLine, startCol, endLine, endCol),
+					code: newContent,
+					originalRange: new Range(originalStartLine, originalStartCol, originalEndLine, originalEndCol),
+					originalCode: originalContent,
+				}
 
 				replacements.push(replacement)
 
@@ -115,187 +129,3 @@ export function findDiffs(oldStr: string, newStr: string) {
 	console.debug('Replacements', replacements)
 	return replacements
 }
-
-
-
-// const diffLinesOld = (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 findDiffsOld = (oldText: string, newText: string): BaseDiff[] => {
-
-// 	const diffs = diffLinesOld(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): BaseDiff[] => {
-
-// 	let diffs = diffLines(oldText, newText)
-// 		.map(diff => {
-// 			const operation = diff.added ? 1 : diff.removed ? -1 : 0;
-// 			const text = diff.value;
-// 			return [operation, text] as const;
-// 		})
-
-
-// 	const blocks: BaseDiff[] = [];
-// 	let reprBlock: string[] = [];
-// 	let deletedBlock: string[] = [];
-// 	let insertedBlock: string[] = [];
-// 	let newFileLine = 0;
-// 	let oldFileLine = 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 = newFileLine;
-// 				newFileLine += lines.length - 1; // update 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 = oldFileLine;
-// 				oldFileLine += lines.length - 1; // update the line count for old text
-// 				deletedBlock.push(text);
-// 				reprBlock.push(lines.map(line => `- ${line}`).join('\n'));
-// 				break;
-
-// 			// no change
-// 			case 0:
-// 				// add pending block 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, oldFileLine, Number.MAX_SAFE_INTEGER),
-// 						insertedRange: new vscode.Range(insertedStart, 0, newFileLine, Number.MAX_SAFE_INTEGER),
-// 					});
-// 				}
-
-// 				// update variables
-// 				reprBlock = [];
-// 				deletedBlock = [];
-// 				insertedBlock = [];
-// 				deletedStart += lines.length - 1;
-// 				insertedStart += lines.length - 1;
-// 				newFileLine += lines.length - 1;
-// 				oldFileLine += 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, oldFileLine, Number.MAX_SAFE_INTEGER),
-// 			insertedRange: new vscode.Range(insertedStart, 0, newFileLine, Number.MAX_SAFE_INTEGER),
-// 		});
-// 	}
-
-// 	return blocks;
-// };
-

extensions/void/src/sidebar/SidebarChat.tsx

@@ -263,10 +263,8 @@ export const SidebarChat = ({ chatInputRef }: { chatInputRef: React.RefObject<HT
 
 				setLatestError(error)
 			},
-			setAbort: (abort) => {
-				abortFnRef.current = abort
-			},
 			voidConfig,
+			abortRef: abortFnRef,
 		})
 
 

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

@@ -12,7 +12,7 @@ enum CopyButtonState {
 
 const COPY_FEEDBACK_TIMEOUT = 1000 // amount of time to say 'Copied!'
 
-const CodeButtonsOnHover = ({ text }: { text: string }) => {
+const CodeButtonsOnHover = ({ diffRepr: text }: { diffRepr: string }) => {
 	const [copyButtonState, setCopyButtonState] = useState(CopyButtonState.Copy)
 
 	useEffect(() => {
@@ -44,7 +44,7 @@ const CodeButtonsOnHover = ({ text }: { text: string }) => {
 		<button
 			className="btn btn-secondary btn-sm border border-vscode-input-border rounded"
 			onClick={async () => {
-				getVSCodeAPI().postMessage({ type: "applyChanges", code: text })
+				getVSCodeAPI().postMessage({ type: "applyChanges", diffRepr: text })
 			}}
 		>
 			Apply
@@ -66,7 +66,7 @@ const RenderToken = ({ token, nested = false }: { token: Token | string, nested?
 		return <BlockCode
 			text={t.text}
 			language={t.lang}
-			buttonsOnHover={<CodeButtonsOnHover text={t.text} />}
+			buttonsOnHover={<CodeButtonsOnHover diffRepr={t.text} />}
 		/>
 	}