Use standard LSP code actions instead of custom commands

Replace custom workspace/executeCommand with standard textDocument/codeAction.
This follows the LSP spec and works with VS Code's built-in Organize Imports.

Changes:
- Remove custom command implementation from extension
- Remove executeCommand handler from LSP server
- Add textDocument/codeAction handler with source.organizeImports kind
- Declare CodeActionProvider in server capabilities
- No client-side changes needed - uses VS Code built-in command

Author: sutong.527608

_extension/package.json

@@ -85,12 +85,6 @@
                 "title": "Show LSP Trace",
                 "enablement": "typescript.native-preview.serverRunning",
                 "category": "TypeScript Native Preview"
-            },
-            {
-                "command": "typescript.native-preview.sortImports",
-                "title": "Sort Imports",
-                "enablement": "typescript.native-preview.serverRunning && editorLangId =~ /^(javascript|typescript|javascriptreact|typescriptreact)$/",
-                "category": "TypeScript Native Preview"
             }
         ]
     },

_extension/src/client.ts

@@ -158,14 +158,4 @@ export class Client {
         this.client.restart();
         return new vscode.Disposable(() => {});
     }
-
-    async executeCommand(command: string, ...args: any[]): Promise<any> {
-        if (!this.client) {
-            throw new Error("Language client is not initialized");
-        }
-        return this.client.sendRequest("workspace/executeCommand", {
-            command,
-            arguments: args,
-        });
-    }
 }

_extension/src/commands.ts

@@ -33,10 +33,6 @@ export function registerLanguageCommands(context: vscode.ExtensionContext, clien
 
     disposables.push(vscode.commands.registerCommand("typescript.native-preview.showMenu", showCommands));
 
-    disposables.push(vscode.commands.registerCommand("typescript.native-preview.sortImports", async () => {
-        return sortImports(client);
-    }));
-
     return disposables;
 }
 
@@ -57,42 +53,11 @@ async function updateUseTsgoSetting(enable: boolean): Promise<void> {
     await vscode.commands.executeCommand("workbench.action.restartExtensionHost");
 }
 
-async function sortImports(client: Client): Promise<void> {
-    const editor = vscode.window.activeTextEditor;
-    if (!editor) {
-        vscode.window.showErrorMessage("No active editor");
-        return;
-    }
-
-    const document = editor.document;
-    const languageId = document.languageId;
-
-    // Check if the file is TypeScript or JavaScript
-    if (!["typescript", "javascript", "typescriptreact", "javascriptreact"].includes(languageId)) {
-        vscode.window.showErrorMessage("Sort Imports is only available for TypeScript and JavaScript files");
-        return;
-    }
-
-    try {
-        // Execute the sort imports command on the server via LSP
-        await client.executeCommand(
-            "typescript-go.organizeImports",
-            document.uri.toString(),
-        );
-        vscode.window.showInformationMessage("Imports sorted successfully");
-    }
-    catch (error) {
-        vscode.window.showErrorMessage(`Failed to sort imports: ${error}`);
-    }
-}
-
+/**
+ * Shows the quick pick menu for TypeScript Native Preview commands
+ */
 async function showCommands(): Promise<void> {
     const commands: readonly { label: string; description: string; command: string; }[] = [
-        {
-            label: "$(symbol-namespace) Sort Imports",
-            description: "Sort imports in the current file",
-            command: "typescript.native-preview.sortImports",
-        },
         {
             label: "$(refresh) Restart Server",
             description: "Restart the TypeScript Native Preview language server",

internal/lsp/server.go

@@ -463,7 +463,7 @@ var handlers = sync.OnceValue(func() handlerMap {
 	registerLanguageServiceDocumentRequestHandler(handlers, lsproto.TextDocumentDocumentHighlightInfo, (*Server).handleDocumentHighlight)
 	registerRequestHandler(handlers, lsproto.WorkspaceSymbolInfo, (*Server).handleWorkspaceSymbol)
 	registerRequestHandler(handlers, lsproto.CompletionItemResolveInfo, (*Server).handleCompletionItemResolve)
-	registerRequestHandler(handlers, lsproto.WorkspaceExecuteCommandInfo, (*Server).handleExecuteCommand)
+	registerLanguageServiceDocumentRequestHandler(handlers, lsproto.TextDocumentCodeActionInfo, (*Server).handleCodeAction)
 
 	return handlers
 })
@@ -641,9 +641,11 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ
 			DocumentHighlightProvider: &lsproto.BooleanOrDocumentHighlightOptions{
 				Boolean: ptrTo(true),
 			},
-			ExecuteCommandProvider: &lsproto.ExecuteCommandOptions{
-				Commands: []string{
-					"typescript-go.organizeImports",
+			CodeActionProvider: &lsproto.BooleanOrCodeActionOptions{
+				CodeActionOptions: &lsproto.CodeActionOptions{
+					CodeActionKinds: &[]lsproto.CodeActionKind{
+						lsproto.CodeActionKindSourceOrganizeImports,
+					},
 				},
 			},
 		},
@@ -850,64 +852,51 @@ func (s *Server) handleDocumentHighlight(ctx context.Context, ls *ls.LanguageSer
 	return ls.ProvideDocumentHighlights(ctx, params.TextDocument.Uri, params.Position)
 }
 
-func (s *Server) handleExecuteCommand(ctx context.Context, params *lsproto.ExecuteCommandParams, _ *lsproto.RequestMessage) (lsproto.ExecuteCommandResponse, error) {
-	switch params.Command {
-	case "typescript-go.organizeImports":
-		return s.handleOrganizeImportsCommand(ctx, params)
-	default:
-		return lsproto.LSPAnyOrNull{}, fmt.Errorf("unknown command: %s", params.Command)
-	}
-}
-
-func (s *Server) handleOrganizeImportsCommand(ctx context.Context, params *lsproto.ExecuteCommandParams) (lsproto.ExecuteCommandResponse, error) {
-	if params.Arguments == nil || len(*params.Arguments) == 0 {
-		return lsproto.LSPAnyOrNull{}, errors.New("organizeImports command requires a document URI argument")
-	}
-
-	var documentURI lsproto.DocumentUri
-	argBytes, err := json.Marshal((*params.Arguments)[0])
-	if err != nil {
-		return lsproto.LSPAnyOrNull{}, fmt.Errorf("failed to marshal argument: %w", err)
-	}
-	err = json.Unmarshal(argBytes, &documentURI)
-	if err != nil {
-		return lsproto.LSPAnyOrNull{}, fmt.Errorf("invalid document URI: %w", err)
-	}
-
-	languageService, err := s.session.GetLanguageService(ctx, documentURI)
-	if err != nil {
-		return lsproto.LSPAnyOrNull{}, err
-	}
-
-	edits, err := languageService.OrganizeImports(ctx, documentURI, ls.OrganizeImportsModeAll)
-	if err != nil {
-		return lsproto.LSPAnyOrNull{}, err
-	}
-
-	if len(edits) == 0 {
-		return lsproto.LSPAnyOrNull{}, nil
+func (s *Server) handleCodeAction(ctx context.Context, languageService *ls.LanguageService, params *lsproto.CodeActionParams) (lsproto.CodeActionResponse, error) {
+	// Check if the client is requesting source.organizeImports
+	requestedOrganizeImports := false
+	if params.Context != nil && params.Context.Only != nil {
+		for _, kind := range *params.Context.Only {
+			if kind == lsproto.CodeActionKindSourceOrganizeImports || kind == lsproto.CodeActionKindSource {
+				requestedOrganizeImports = true
+				break
+			}
+		}
+	} else {
+		// If no specific kinds are requested, include organize imports
+		requestedOrganizeImports = true
 	}
 
-	editPtrs := make([]*lsproto.TextEdit, len(edits))
-	for i := range edits {
-		editPtrs[i] = &edits[i]
-	}
+	var actions []lsproto.CommandOrCodeAction
+	if requestedOrganizeImports {
+		edits, err := languageService.OrganizeImports(ctx, params.TextDocument.Uri, ls.OrganizeImportsModeAll)
+		if err != nil {
+			return lsproto.CommandOrCodeActionArrayOrNull{}, err
+		}
 
-	workspaceEdit := &lsproto.WorkspaceEdit{
-		Changes: &map[lsproto.DocumentUri][]*lsproto.TextEdit{
-			documentURI: editPtrs,
-		},
-	}
+		if len(edits) > 0 {
+			editPtrs := make([]*lsproto.TextEdit, len(edits))
+			for i := range edits {
+				editPtrs[i] = &edits[i]
+			}
 
-	_, err = s.sendRequest(ctx, lsproto.MethodWorkspaceApplyEdit, &lsproto.ApplyWorkspaceEditParams{
-		Label: ptrTo("Organize Imports"),
-		Edit:  workspaceEdit,
-	})
-	if err != nil {
-		return lsproto.LSPAnyOrNull{}, fmt.Errorf("failed to apply workspace edit: %w", err)
+			kind := lsproto.CodeActionKindSourceOrganizeImports
+			action := lsproto.CommandOrCodeAction{
+				CodeAction: &lsproto.CodeAction{
+					Title: "Organize Imports",
+					Kind:  &kind,
+					Edit: &lsproto.WorkspaceEdit{
+						Changes: &map[lsproto.DocumentUri][]*lsproto.TextEdit{
+							params.TextDocument.Uri: editPtrs,
+						},
+					},
+				},
+			}
+			actions = append(actions, action)
+		}
 	}
 
-	return lsproto.LSPAnyOrNull{}, nil
+	return lsproto.CommandOrCodeActionArrayOrNull{CommandOrCodeActionArray: &actions}, nil
 }
 
 func (s *Server) Log(msg ...any) {