style: fix format style

wenytang-ms · wenytang-ms · commit ada72e1cb339 · 2025-10-30T15:11:48.000+08:00
diff --git a/src/copilot/contextProvider.ts b/src/copilot/contextProvider.ts
@@ -29,30 +29,28 @@ export async function registerCopilotContextProviders(
         if (!apis.clientApi || !apis.chatApi) {
             return;
         }
-
         // Register the Java completion context provider
         const provider: ContextProvider<SupportedContextItem> = {
             id: 'vscjava.vscode-java-dependency', // use extension id as provider id for now
             selector: [{ language: "java" }],
             resolver: { resolve: createJavaContextResolver() }
         };
-
         const installCount = await JavaContextProviderUtils.installContextProviderOnApis(apis, provider, context, installContextProvider);
-
         if (installCount === 0) {
             return;
         }
-        
         sendInfo("", {
             "action": "registerCopilotContextProvider",
             "extension": 'vscjava.vscode-java-dependency',
             "status": "succeeded",
             "installCount": installCount
         });
-        console.log(`Registered Copilot context provider for Java on ${installCount} APIs.`);
     }
     catch (error) {
-        sendError(new ContextProviderRegistrationError('Failed to register Copilot context provider: ' + ((error as Error).message || "unknown_error")));
+        const errorMessage = (error as Error).message || "unknown_error";
+        sendError(new ContextProviderRegistrationError(
+            'Failed to register Copilot context provider: ' + errorMessage
+        ));
     }
 }
 
@@ -64,7 +62,6 @@ function createJavaContextResolver(): ContextResolverFunction {
         try {
             // Check for immediate cancellation
             JavaContextProviderUtils.checkCancellation(copilotCancel);
-            
             return await resolveJavaContext(request, copilotCancel);
         } catch (error: any) {
             sendError(new ContextProviderResolverError('Java Context Resolution Failed: ' + ((error as Error).message || "unknown_error")));
@@ -88,42 +85,36 @@ function sendContextTelemetry(request: ResolveRequest, start: number, items: Sup
         "tokenCount": tokenCount,
         "status": status
     };
-    
     if (error) {
         telemetryData.error = error;
     }
-    
     sendInfo("", telemetryData);
 }
 
 async function resolveJavaContext(request: ResolveRequest, copilotCancel: vscode.CancellationToken): Promise<SupportedContextItem[]> {
     const items: SupportedContextItem[] = [];
     const start = performance.now();
-    
     try {
         // Check for cancellation before starting
         JavaContextProviderUtils.checkCancellation(copilotCancel);
-        
         // Resolve project dependencies and convert to context items
         const projectDependencyItems = await CopilotHelper.resolveAndConvertProjectDependencies(
             vscode.workspace.workspaceFolders,
             copilotCancel,
             JavaContextProviderUtils.checkCancellation
         );
         JavaContextProviderUtils.checkCancellation(copilotCancel);
-        console.dir(projectDependencyItems);
         items.push(...projectDependencyItems);
 
         JavaContextProviderUtils.checkCancellation(copilotCancel);
-        
+
         // Resolve local imports and convert to context items
         const localImportItems = await CopilotHelper.resolveAndConvertLocalImports(
             vscode.window.activeTextEditor,
             copilotCancel,
             JavaContextProviderUtils.checkCancellation
         );
         JavaContextProviderUtils.checkCancellation(copilotCancel);
-        console.dir(localImportItems);
         items.push(...localImportItems);
     } catch (error: any) {
         if (error instanceof CopilotCancellationError) {
@@ -134,17 +125,17 @@ async function resolveJavaContext(request: ResolveRequest, copilotCancel: vscode
             sendContextTelemetry(request, start, items, "cancelled_internally");
             throw new InternalCancellationError();
         }
-        
+
         // Send telemetry for general errors (but continue with partial results)
         sendContextTelemetry(request, start, items, "error_partial_results", error.message || "unknown_error");
-        
+
         // Return partial results and log completion for error case
         return items;
     }
 
     // Send telemetry data once at the end for success case
     sendContextTelemetry(request, start, items, "succeeded");
-    
+
     return items;
 }
 
diff --git a/src/copilot/copilotHelper.ts b/src/copilot/copilotHelper.ts
@@ -44,7 +44,7 @@ export interface IProjectDependency {
 }
 
 export interface IProjectDependenciesResult {
-    dependencyInfoList: Array<{ key: string; value: string }>;
+    dependencyInfoList: { key: string; value: string }[];
     emptyReason?: string;
     isEmpty: boolean;
 }
@@ -80,9 +80,11 @@ export namespace CopilotHelper {
 
         try {
             const normalizedUri = decodeURIComponent(Uri.file(fileUri.fsPath).toString());
-            
-            const commandPromise = commands.executeCommand(Commands.EXECUTE_WORKSPACE_COMMAND, Commands.JAVA_PROJECT_GET_IMPORT_CLASS_CONTENT, normalizedUri) as Promise<IImportClassContentResult>;
-            
+            const commandPromise = commands.executeCommand(
+                Commands.EXECUTE_WORKSPACE_COMMAND,
+                Commands.JAVA_PROJECT_GET_IMPORT_CLASS_CONTENT,
+                normalizedUri
+            ) as Promise<IImportClassContentResult>;
             if (cancellationToken) {
                 const result = await Promise.race([
                     commandPromise,
@@ -97,15 +99,13 @@ export namespace CopilotHelper {
                         }, 80); // 80ms timeout
                     })
                 ]);
-                
                 if (!result) {
                     return {
                         classInfoList: [],
                         emptyReason: EmptyReason.CommandNullResult,
                         isEmpty: true
                     };
                 }
-                
                 return result;
             } else {
                 const result = await Promise.race([
@@ -116,15 +116,13 @@ export namespace CopilotHelper {
                         }, 80); // 80ms timeout
                     })
                 ]);
-                
                 if (!result) {
                     return {
                         classInfoList: [],
                         emptyReason: EmptyReason.CommandNullResult,
                         isEmpty: true
                     };
                 }
-                
                 return result;
             }
         } catch (error: any) {
@@ -135,15 +133,13 @@ export namespace CopilotHelper {
                     isEmpty: true
                 };
             }
-            
             if (error.message === ErrorMessage.OperationTimedOut) {
                 return {
                     classInfoList: [],
                     emptyReason: EmptyReason.Timeout,
                     isEmpty: true
                 };
             }
-            
             const errorMessage = 'TsException_' + ((error as Error).message || "unknown");
             sendError(new GetImportClassContentError(errorMessage));
             return {
@@ -162,13 +158,13 @@ export namespace CopilotHelper {
      */
     export async function resolveProjectDependencies(projectUri: Uri, cancellationToken?: CancellationToken): Promise<IProjectDependency> {
         const result = await resolveProjectDependenciesWithReason(projectUri, cancellationToken);
-        
+
         // Convert to legacy format
         const dependencies: IProjectDependency = {};
         for (const dep of result.dependencyInfoList) {
             dependencies[dep.key] = dep.value;
         }
-        
+
         return dependencies;
     }
 
@@ -178,7 +174,10 @@ export namespace CopilotHelper {
      * @param cancellationToken Optional cancellation token to abort the operation
      * @returns Result object containing project dependencies and error information
      */
-    export async function resolveProjectDependenciesWithReason(projectUri: Uri, cancellationToken?: CancellationToken): Promise<IProjectDependenciesResult> {
+    export async function resolveProjectDependenciesWithReason(
+        projectUri: Uri,
+        cancellationToken?: CancellationToken
+    ): Promise<IProjectDependenciesResult> {
         if (cancellationToken?.isCancellationRequested) {
             return {
                 dependencyInfoList: [],
@@ -189,9 +188,12 @@ export namespace CopilotHelper {
 
         try {
             const normalizedUri = decodeURIComponent(Uri.file(projectUri.fsPath).toString());
+            const commandPromise = commands.executeCommand(
+                Commands.EXECUTE_WORKSPACE_COMMAND,
+                Commands.JAVA_PROJECT_GET_DEPENDENCIES,
+                normalizedUri
+            ) as Promise<IProjectDependenciesResult>;
 
-            const commandPromise = commands.executeCommand(Commands.EXECUTE_WORKSPACE_COMMAND, Commands.JAVA_PROJECT_GET_DEPENDENCIES, normalizedUri) as Promise<IProjectDependenciesResult>;
-            
             if (cancellationToken) {
                 const result = await Promise.race([
                     commandPromise,
@@ -206,15 +208,13 @@ export namespace CopilotHelper {
                         }, 40); // 40ms timeout
                     })
                 ]);
-                
                 if (!result) {
                     return {
                         dependencyInfoList: [],
                         emptyReason: EmptyReason.CommandNullResult,
                         isEmpty: true
                     };
                 }
-                
                 return result;
             } else {
                 const result = await Promise.race([
@@ -225,15 +225,13 @@ export namespace CopilotHelper {
                         }, 40); // 40ms timeout
                     })
                 ]);
-                
                 if (!result) {
                     return {
                         dependencyInfoList: [],
                         emptyReason: EmptyReason.CommandNullResult,
                         isEmpty: true
                     };
                 }
-                
                 return result;
             }
         } catch (error: any) {
@@ -244,15 +242,13 @@ export namespace CopilotHelper {
                     isEmpty: true
                 };
             }
-            
             if (error.message === ErrorMessage.OperationTimedOut) {
                 return {
                     dependencyInfoList: [],
                     emptyReason: EmptyReason.Timeout,
                     isEmpty: true
                 };
             }
-            
             const errorMessage = 'TsException_' + ((error as Error).message || "unknown");
             sendError(new GetProjectDependenciesError(errorMessage));
             return {
@@ -274,40 +270,38 @@ export namespace CopilotHelper {
         workspaceFolders: readonly { uri: Uri }[] | undefined,
         copilotCancel: CancellationToken,
         checkCancellation: (token: CancellationToken) => void
-    ): Promise<Array<{ name: string; value: string; importance: number }>> {
+    ): Promise<{ name: string; value: string; importance: number }[]> {
         const items: any[] = [];
-        
         // Check if workspace folders exist
         if (!workspaceFolders || workspaceFolders.length === 0) {
             sendContextOperationTelemetry("resolveProjectDependencies", "ContextEmpty", sendInfo, EmptyReason.NoWorkspace);
             return items;
         }
-        
         const projectUri = workspaceFolders[0];
-        
+
         // Resolve project dependencies
         const projectDependenciesResult = await resolveProjectDependenciesWithReason(projectUri.uri, copilotCancel);
-        
+
         // Check for cancellation after dependency resolution
         checkCancellation(copilotCancel);
-        
+
         // Send telemetry if result is empty
         if (projectDependenciesResult.isEmpty && projectDependenciesResult.emptyReason) {
             sendContextOperationTelemetry("resolveProjectDependencies", "ContextEmpty", sendInfo, projectDependenciesResult.emptyReason);
         }
-        
+
         // Check for cancellation after telemetry
         checkCancellation(copilotCancel);
-        
+
         // Convert project dependencies to context items
         if (projectDependenciesResult.dependencyInfoList && projectDependenciesResult.dependencyInfoList.length > 0) {
             const contextItems = JavaContextProviderUtils.createContextItemsFromProjectDependencies(projectDependenciesResult.dependencyInfoList);
-            
+
             // Check cancellation once after creating all items
             checkCancellation(copilotCancel);
             items.push(...contextItems);
         }
-        
+
         return items;
     }
 
@@ -325,46 +319,40 @@ export namespace CopilotHelper {
         checkCancellation: (token: CancellationToken) => void
     ): Promise<any[]> {
         const items: any[] = [];
-        
         // Check if there's an active editor with a Java document
         if (!activeEditor) {
             sendContextOperationTelemetry("resolveLocalImports", "ContextEmpty", sendInfo, EmptyReason.NoActiveEditor);
             return items;
         }
-        
         if (activeEditor.document.languageId !== 'java') {
             sendContextOperationTelemetry("resolveLocalImports", "ContextEmpty", sendInfo, EmptyReason.NotJavaFile);
             return items;
         }
-        
+
         const documentUri = activeEditor.document.uri;
-        
+
         // Check for cancellation before resolving imports
         checkCancellation(copilotCancel);
-
         // Resolve imports directly without caching
         const importClassResult = await resolveLocalImportsWithReason(documentUri, copilotCancel);
-        
+
         // Check for cancellation after resolution
         checkCancellation(copilotCancel);
-        
+
         // Send telemetry if result is empty
         if (importClassResult.isEmpty && importClassResult.emptyReason) {
             sendContextOperationTelemetry("resolveLocalImports", "ContextEmpty", sendInfo, importClassResult.emptyReason);
         }
         // Check for cancellation before processing results
         checkCancellation(copilotCancel);
-
         if (importClassResult.classInfoList && importClassResult.classInfoList.length > 0) {
             // Process imports in batches to reduce cancellation check overhead
             const contextItems = JavaContextProviderUtils.createContextItemsFromImports(importClassResult.classInfoList);
-            
             // Check cancellation once after creating all items
             checkCancellation(copilotCancel);
-            
             items.push(...contextItems);
         }
-        
+
         return items;
     }
 }
diff --git a/src/copilot/utils.ts b/src/copilot/utils.ts
