add more try-catch for error handling

Author: tomcat323

packages/core/src/codewhisperer/nextEditPrediction/PredictionTracker.ts

@@ -54,20 +54,20 @@ export class PredictionTracker {
             return
         }
 
-        // Get existing snapshots for this file
-        const fileSnapshots = this.snapshots.get(filePath) || []
-        const timestamp = globals.clock.Date.now()
+        try {
+            // Get existing snapshots for this file
+            const fileSnapshots = this.snapshots.get(filePath) || []
+            const timestamp = globals.clock.Date.now()
 
-        // Anti-throttling, only add snap shot after the debounce is cleared
-        const shouldAddSnapshot =
-            fileSnapshots.length === 0 ||
-            timestamp - fileSnapshots[fileSnapshots.length - 1].timestamp > this.config.debounceIntervalMs
+            // Anti-throttling, only add snap shot after the debounce is cleared
+            const shouldAddSnapshot =
+                fileSnapshots.length === 0 ||
+                timestamp - fileSnapshots[fileSnapshots.length - 1].timestamp > this.config.debounceIntervalMs
 
-        if (!shouldAddSnapshot) {
-            return
-        }
+            if (!shouldAddSnapshot) {
+                return
+            }
 
-        try {
             const content = previousContent
             const size = Buffer.byteLength(content, 'utf8')
             const snapshot: FileSnapshot = {
@@ -201,32 +201,38 @@ export class PredictionTracker {
      * @returns Array of SupplementalContext objects containing diffs between snapshots and current content
      */
     public async generatePredictionSupplementalContext(): Promise<codewhispererClient.SupplementalContext[]> {
-        const activeEditor = vscode.window.activeTextEditor
-        if (activeEditor === undefined) {
-            return []
-        }
-        const filePath = activeEditor.document.uri.fsPath
-        const currentContent = activeEditor.document.getText()
-        const snapshots = this.getFileSnapshots(filePath)
+        try {
+            const activeEditor = vscode.window.activeTextEditor
+            if (activeEditor === undefined) {
+                return []
+            }
+            const filePath = activeEditor.document.uri.fsPath
+            const currentContent = activeEditor.document.getText()
+            const snapshots = this.getFileSnapshots(filePath)
 
-        if (snapshots.length === 0) {
+            if (snapshots.length === 0) {
+                return []
+            }
+
+            // Create SnapshotContent array from snapshots
+            const snapshotContents: diffGenerator.SnapshotContent[] = snapshots.map((snapshot) => ({
+                filePath: snapshot.filePath,
+                content: snapshot.content,
+                timestamp: snapshot.timestamp,
+            }))
+
+            // Use the diffGenerator module to generate supplemental contexts
+            return diffGenerator.generateDiffContexts(
+                filePath,
+                currentContent,
+                snapshotContents,
+                this.config.maxSupplementalContext
+            )
+        } catch (err) {
+            // this ensures we are not breaking inline requests
+            this.logger.error(`Failed to generate prediction supplemental context: ${err}`)
             return []
         }
-
-        // Create SnapshotContent array from snapshots
-        const snapshotContents: diffGenerator.SnapshotContent[] = snapshots.map((snapshot) => ({
-            filePath: snapshot.filePath,
-            content: snapshot.content,
-            timestamp: snapshot.timestamp,
-        }))
-
-        // Use the diffGenerator module to generate supplemental contexts
-        return diffGenerator.generateDiffContexts(
-            filePath,
-            currentContent,
-            snapshotContents,
-            this.config.maxSupplementalContext
-        )
     }
 
     public getTotalSize() {

packages/core/src/codewhisperer/nextEditPrediction/activation.ts

@@ -13,16 +13,20 @@ export let predictionTracker: PredictionTracker | undefined
 let keyStrokeHandler: PredictionKeyStrokeHandler | undefined
 
 export function activateEditTracking(context: ExtContext): void {
-    predictionTracker = new PredictionTracker(context.extensionContext)
+    try {
+        predictionTracker = new PredictionTracker(context.extensionContext)
 
-    keyStrokeHandler = new PredictionKeyStrokeHandler(predictionTracker)
-    context.extensionContext.subscriptions.push(
-        vscode.Disposable.from({
-            dispose: () => {
-                keyStrokeHandler?.dispose()
-            },
-        })
-    )
+        keyStrokeHandler = new PredictionKeyStrokeHandler(predictionTracker)
+        context.extensionContext.subscriptions.push(
+            vscode.Disposable.from({
+                dispose: () => {
+                    keyStrokeHandler?.dispose()
+                },
+            })
+        )
 
-    getLogger('nextEditPrediction').debug('Next Edit Prediction activated')
+        getLogger('nextEditPrediction').debug('Next Edit Prediction activated')
+    } catch (error) {
+        getLogger('nextEditPrediction').error(`Error in activateEditTracking: ${error}`)
+    }
 }

packages/core/src/codewhisperer/util/editorContext.ts

@@ -122,42 +122,23 @@ export async function buildListRecommendationRequest(
 
     // Get predictionSupplementalContext from PredictionTracker
     let predictionSupplementalContext: codewhispererClient.SupplementalContext[] = []
-    try {
-        if (predictionTracker) {
-            predictionSupplementalContext = await predictionTracker.generatePredictionSupplementalContext()
-        }
-    } catch (error) {
-        getLogger().error(`Error getting prediction supplemental context: ${error}`)
+    if (predictionTracker) {
+        predictionSupplementalContext = await predictionTracker.generatePredictionSupplementalContext()
     }
 
     const selectedCustomization = getSelectedCustomization()
-    const inlineSupplementalContext: codewhispererClient.SupplementalContext[] = supplementalContexts
+    const completionSupplementalContext: codewhispererClient.SupplementalContext[] = supplementalContexts
         ? supplementalContexts.supplementalContextItems.map((v) => {
               return selectFrom(v, 'content', 'filePath')
           })
         : []
 
     const profile = AuthUtil.instance.regionProfileManager.activeRegionProfile
 
-    // Dynamically create editorState from current editor context
-    const editorState = {
-        document: {
-            programmingLanguage: {
-                languageName: fileContext.programmingLanguage.languageName,
-            },
-            relativeFilePath: fileContext.filename,
-            text: editor.document.getText(),
-        },
-        cursorState: {
-            position: {
-                line: editor.selection.active.line,
-                character: editor.selection.active.character,
-            },
-        },
-    }
+    const editorState = getEditorState(editor, fileContext)
 
     // Combine inline and prediction supplemental contexts
-    const finalSupplementalContext = inlineSupplementalContext.concat(predictionSupplementalContext)
+    const finalSupplementalContext = completionSupplementalContext.concat(predictionSupplementalContext)
     return {
         request: {
             fileContext: fileContext,
@@ -233,6 +214,29 @@ export function getTabSize(): number {
     return tabSize
 }
 
+export function getEditorState(editor: vscode.TextEditor, fileContext: codewhispererClient.FileContext): any {
+    try {
+        return {
+            document: {
+                programmingLanguage: {
+                    languageName: fileContext.programmingLanguage.languageName,
+                },
+                relativeFilePath: fileContext.filename,
+                text: editor.document.getText(),
+            },
+            cursorState: {
+                position: {
+                    line: editor.selection.active.line,
+                    character: editor.selection.active.character,
+                },
+            },
+        }
+    } catch (error) {
+        getLogger().error(`Error generating editor state: ${error}`)
+        return undefined
+    }
+}
+
 export function getLeftContext(editor: vscode.TextEditor, line: number): string {
     let lineText = ''
     try {