feat(extension): add workspace solution picker

Author: govert

README.md

@@ -127,6 +127,8 @@ Once installed, the extension automatically activates when you open a \`.vb\` fi
 3. The extension will automatically discover and load your `VB.NET` projects
 4. Start coding with full IntelliSense support
 
+If you have multiple solutions, use the Command Palette action **"VB.NET: Select Workspace Solution"** to choose the active \`.sln/.slnf/.slnx\`.
+
 ## Architecture
 
 `VB.NET` Language Support follows the architecture of the "C# for Visual Studio Code" extension:

docs/configuration.md

@@ -22,6 +22,11 @@ Last Updated: 2026-01-20
 - **UI**: File > Preferences > Settings > Extensions > `VB.NET` Language Support
 - **JSON**: `.vscode/settings.json` (workspace) or User Settings (global)
 
+### Commands
+
+- **`VB.NET: Select Workspace Solution`** — choose a `.sln/.slnf/.slnx` file and update
+  `vbnet.workspace.solutionPath`. Pick "Auto-detect" to clear the override.
+
 ---
 
 ## 2. VS Code Settings

src/VbNet.LanguageServer.Vb/Core/LanguageServer.vb

@@ -1274,6 +1274,9 @@ Namespace Core
 
         Private Shared Function SolutionContainsVbProject(solutionPath As String) As Boolean
             Try
+                If solutionPath.EndsWith(".slnx", StringComparison.OrdinalIgnoreCase) Then
+                    Return True
+                End If
                 Dim content = File.ReadAllText(solutionPath)
                 Return content.IndexOf(".vbproj", StringComparison.OrdinalIgnoreCase) >= 0
             Catch
@@ -1326,6 +1329,7 @@ Namespace Core
 
                 Dim solutionCandidates = Directory.EnumerateFiles(searchRoot, "*.sln", SearchOption.TopDirectoryOnly) _
                     .Concat(Directory.EnumerateFiles(searchRoot, "*.slnf", SearchOption.TopDirectoryOnly)) _
+                    .Concat(Directory.EnumerateFiles(searchRoot, "*.slnx", SearchOption.TopDirectoryOnly)) _
                     .OrderBy(Function(path) path, StringComparer.OrdinalIgnoreCase) _
                     .ToList()
 

src/extension/package.json

@@ -215,6 +215,11 @@
         "title": "Restart VB.NET Language Server",
         "category": "VB.NET"
       },
+      {
+        "command": "vbnet.selectWorkspaceSolution",
+        "title": "Select VB.NET Workspace Solution",
+        "category": "VB.NET"
+      },
       {
         "command": "vbnet.showOutputChannel",
         "title": "Show VB.NET Output",

src/extension/src/extension.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
+import * as path from 'path';
 import { PlatformInformation } from './platform';
 import { VbNetLanguageClient } from './languageClient';
 import { VbNetStatusBar } from './statusBar';
@@ -175,6 +176,127 @@ function registerCommands(context: vscode.ExtensionContext): void {
             outputChannel?.show();
         })
     );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('vbnet.selectWorkspaceSolution', async () => {
+            try {
+                await selectWorkspaceSolution();
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                outputChannel?.appendLine(`Failed to select workspace solution: ${message}`);
+                vscode.window.showErrorMessage(`Failed to select workspace solution: ${message}`);
+            }
+        })
+    );
+}
+
+interface SolutionPickItem extends vscode.QuickPickItem {
+    solutionPath?: string;
+    action?: 'clear';
+}
+
+async function selectWorkspaceSolution(): Promise<void> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+        vscode.window.showWarningMessage('No workspace folder is open.');
+        return;
+    }
+
+    const config = vscode.workspace.getConfiguration('vbnet');
+    const defaultExclude = '**/node_modules/**,**/.git/**,**/bower_components/**';
+    const excludePattern = config.get<string>('workspace.projectFilesExcludePattern', defaultExclude);
+
+    const resources = await vscode.workspace.findFiles(
+        '{**/*.sln,**/*.slnf,**/*.slnx}',
+        `{${excludePattern}}`
+    );
+
+    if (resources.length === 0) {
+        vscode.window.showInformationMessage('No solution files were found in this workspace.');
+        return;
+    }
+
+    const workspaceRoot = workspaceFolders[0].uri.fsPath;
+    const configuredSolution = (config.get<string>('workspace.solutionPath', '') || '').trim();
+    const configuredResolved = configuredSolution
+        ? path.normalize(path.resolve(workspaceRoot, configuredSolution))
+        : '';
+
+    const items: SolutionPickItem[] = [];
+    items.push({
+        label: 'Auto-detect',
+        description: 'Clear workspace solution override',
+        action: 'clear'
+    });
+
+    const candidates = resources
+        .map((resource) => resource.fsPath)
+        .sort((a, b) => a.localeCompare(b));
+
+    for (const candidate of candidates) {
+        const resolved = path.normalize(candidate);
+        const relative = path.relative(workspaceRoot, candidate);
+        const isRelative = relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+        const label = isRelative ? relative : path.basename(candidate);
+
+        const hasVb = await solutionLikelyHasVbProjects(candidate);
+        let description: string | undefined = undefined;
+        if (configuredResolved && resolved === configuredResolved) {
+            description = 'Current selection';
+        } else if (!hasVb) {
+            description = 'No .vbproj references detected';
+        }
+
+        items.push({
+            label,
+            description,
+            detail: candidate,
+            solutionPath: candidate
+        });
+    }
+
+    const pick = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select a workspace solution for VB.NET (clears auto-detection)',
+        canPickMany: false
+    });
+
+    if (!pick) {
+        return;
+    }
+
+    if (pick.action === 'clear') {
+        await config.update('workspace.solutionPath', '', vscode.ConfigurationTarget.Workspace);
+        outputChannel?.appendLine('Workspace solution override cleared (auto-detect enabled).');
+        vscode.window.showInformationMessage('Workspace solution override cleared (auto-detect enabled).');
+        return;
+    }
+
+    if (!pick.solutionPath) {
+        return;
+    }
+
+    const relative = path.relative(workspaceRoot, pick.solutionPath);
+    const configValue = relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+        ? relative
+        : pick.solutionPath;
+
+    await config.update('workspace.solutionPath', configValue, vscode.ConfigurationTarget.Workspace);
+    outputChannel?.appendLine(`Workspace solution override set to: ${configValue}`);
+    vscode.window.showInformationMessage(`Workspace solution set to ${configValue}`);
+}
+
+async function solutionLikelyHasVbProjects(solutionPath: string): Promise<boolean> {
+    if (solutionPath.toLowerCase().endsWith('.slnx')) {
+        return true;
+    }
+
+    try {
+        const content = await vscode.workspace.fs.readFile(vscode.Uri.file(solutionPath));
+        const text = Buffer.from(content).toString('utf8');
+        return text.toLowerCase().includes('.vbproj');
+    } catch {
+        return true;
+    }
 }
 
 /**

src/extension/src/languageClient.ts

@@ -5,6 +5,7 @@
 
 import * as vscode from 'vscode';
 import * as net from 'net';
+import * as path from 'path';
 import {
     LanguageClient,
     LanguageClientOptions,
@@ -207,6 +208,7 @@ export class VbNetLanguageClient implements vscode.Disposable {
                     vscode.workspace.createFileSystemWatcher('**/*.vbproj'),
                     vscode.workspace.createFileSystemWatcher('**/*.sln'),
                     vscode.workspace.createFileSystemWatcher('**/*.slnf'),
+                    vscode.workspace.createFileSystemWatcher('**/*.slnx'),
                     vscode.workspace.createFileSystemWatcher('**/Directory.Build.props'),
                     vscode.workspace.createFileSystemWatcher('**/Directory.Build.targets')
                 ]
@@ -336,12 +338,12 @@ export class VbNetLanguageClient implements vscode.Disposable {
         }
 
         const resources = await vscode.workspace.findFiles(
-            '{**/*.sln,**/*.slnf,**/*.vbproj}',
+            '{**/*.sln,**/*.slnf,**/*.slnx,**/*.vbproj}',
             `{${excludePattern}}`
         );
 
         const workspaceRoot = workspaceFolders[0].uri.fsPath;
-        const solutionCandidates = resources.filter((resource) => /\.slnf?$/i.test(resource.fsPath));
+        const solutionCandidates = resources.filter((resource) => /\.(sln|slnf|slnx)$/i.test(resource.fsPath));
         const vbProjectFiles = resources.filter((resource) => /\.vbproj$/i.test(resource.fsPath));
 
         const solutionPath = await this.pickSolutionWithVbProjects(solutionCandidates);
@@ -382,6 +384,11 @@ export class VbNetLanguageClient implements vscode.Disposable {
         const filtered = [];
         for (const candidate of candidates) {
             try {
+                const extension = path.extname(candidate.fsPath).toLowerCase();
+                if (extension === '.slnx') {
+                    filtered.push(candidate);
+                    continue;
+                }
                 const content = await vscode.workspace.fs.readFile(candidate);
                 const text = Buffer.from(content).toString('utf8');
                 if (text.toLowerCase().includes('.vbproj')) {

test-explore/TEST_RESULTS.md

@@ -47,6 +47,15 @@ Optional flags:
 
 ## Recent runs
 
+### 2026-01-22 — VS Code harness (VB.NET server)
+
+Command:
+- `cd test-explore\\clients\\vscode; npm test`
+
+Outcome: PASS (14 passing, 5 pending)
+Notes:
+- DAP trace: `test-explore/clients/vscode/logs/dap-trace-2026-01-22T195325297Z.log`.
+
 ### 2026-01-20 � test-explore suite (all, VB.NET)
 
 Command:

test-explore/clients/vscode/src/suite/vbnet-extension.test.ts

@@ -271,8 +271,10 @@ if (skipVbnetSmoke) {
         const config = vscode.workspace.getConfiguration("vbnet");
         const originalTransport = config.get<string>("server.transportType", "auto");
         const originalTrace = config.get<string>("trace.server", "off");
+        const commands = await vscode.commands.getCommands(true);
 
         try {
+            assert.ok(commands.includes("vbnet.selectWorkspaceSolution"), "Select workspace solution command not registered.");
             await config.update("trace.server", "verbose", vscode.ConfigurationTarget.Workspace);
             await config.update("server.transportType", "namedPipe", vscode.ConfigurationTarget.Workspace);
 

test/VbNet.Extension.Tests.Vb/ExtensionManifestTests.vb

@@ -58,6 +58,15 @@ Namespace VbNet.Extension.Tests
 
             Assert.True(launchProps.TryGetProperty("projectPath", Nothing), "Expected launch configuration to include projectPath.")
         End Sub
+
+        <Fact>
+        Public Sub CommandsIncludeWorkspaceSolutionPicker()
+            Dim root = LoadPackageJson()
+            Dim commands = root.GetProperty("contributes").GetProperty("commands")
+
+            Dim hasCommand = commands.EnumerateArray().Any(Function(item) item.GetProperty("command").GetString() = "vbnet.selectWorkspaceSolution")
+            Assert.True(hasCommand, "Expected vbnet.selectWorkspaceSolution to be contributed in package.json.")
+        End Sub
     End Class
 
 End Namespace