@nogataka/smart-edit 0.0.14

package/dist/solidlsp/language_servers/csharp_language_server.js

@@ -0,0 +1,694 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createSerenaLogger } from '../../serena/util/logging.js';
+import { Language } from '../ls_config.js';
+import { ensureDefaultSubprocessOptions } from '../util/subprocess_util.js';
+import { SolidLanguageServer, SolidLspSettings, registerLanguageServer, coerceLogLevel } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { RuntimeDependencyCollection } from './common.js';
+import { SafeZipExtractor } from '../util/zip.js';
+const NUGET_SERVICE_INDEX = 'https://pkgs.dev.azure.com/azure-public/vside/_packaging/vs-impl/nuget/v3/index.json';
+const RUNTIME_DEPENDENCIES = [
+    {
+        id: 'CSharpLanguageServer',
+        packageName: 'Microsoft.CodeAnalysis.LanguageServer.win-x64',
+        packageVersion: '5.0.0-1.25329.6',
+        platformId: 'win-x64',
+        archiveType: 'nupkg',
+        binaryName: 'Microsoft.CodeAnalysis.LanguageServer.dll',
+        extractPath: 'content/LanguageServer/win-x64'
+    },
+    {
+        id: 'CSharpLanguageServer',
+        packageName: 'Microsoft.CodeAnalysis.LanguageServer.win-arm64',
+        packageVersion: '5.0.0-1.25329.6',
+        platformId: 'win-arm64',
+        archiveType: 'nupkg',
+        binaryName: 'Microsoft.CodeAnalysis.LanguageServer.dll',
+        extractPath: 'content/LanguageServer/win-arm64'
+    },
+    {
+        id: 'CSharpLanguageServer',
+        packageName: 'Microsoft.CodeAnalysis.LanguageServer.osx-x64',
+        packageVersion: '5.0.0-1.25329.6',
+        platformId: 'osx-x64',
+        archiveType: 'nupkg',
+        binaryName: 'Microsoft.CodeAnalysis.LanguageServer.dll',
+        extractPath: 'content/LanguageServer/osx-x64'
+    },
+    {
+        id: 'CSharpLanguageServer',
+        packageName: 'Microsoft.CodeAnalysis.LanguageServer.osx-arm64',
+        packageVersion: '5.0.0-1.25329.6',
+        platformId: 'osx-arm64',
+        archiveType: 'nupkg',
+        binaryName: 'Microsoft.CodeAnalysis.LanguageServer.dll',
+        extractPath: 'content/LanguageServer/osx-arm64'
+    },
+    {
+        id: 'CSharpLanguageServer',
+        packageName: 'Microsoft.CodeAnalysis.LanguageServer.linux-x64',
+        packageVersion: '5.0.0-1.25329.6',
+        platformId: 'linux-x64',
+        archiveType: 'nupkg',
+        binaryName: 'Microsoft.CodeAnalysis.LanguageServer.dll',
+        extractPath: 'content/LanguageServer/linux-x64'
+    },
+    {
+        id: 'CSharpLanguageServer',
+        packageName: 'Microsoft.CodeAnalysis.LanguageServer.linux-arm64',
+        packageVersion: '5.0.0-1.25329.6',
+        platformId: 'linux-arm64',
+        archiveType: 'nupkg',
+        binaryName: 'Microsoft.CodeAnalysis.LanguageServer.dll',
+        extractPath: 'content/LanguageServer/linux-arm64'
+    },
+    {
+        id: 'DotNetRuntime',
+        url: 'https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-win-x64.zip',
+        platformId: 'win-x64',
+        archiveType: 'zip',
+        binaryName: 'dotnet.exe'
+    },
+    {
+        id: 'DotNetRuntime',
+        url: 'https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-win-arm64.zip',
+        platformId: 'win-arm64',
+        archiveType: 'zip',
+        binaryName: 'dotnet.exe'
+    },
+    {
+        id: 'DotNetRuntime',
+        url: 'https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-linux-x64.tar.gz',
+        platformId: 'linux-x64',
+        archiveType: 'tar.gz',
+        binaryName: 'dotnet'
+    },
+    {
+        id: 'DotNetRuntime',
+        url: 'https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-linux-arm64.tar.gz',
+        platformId: 'linux-arm64',
+        archiveType: 'tar.gz',
+        binaryName: 'dotnet'
+    },
+    {
+        id: 'DotNetRuntime',
+        url: 'https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-osx-x64.tar.gz',
+        platformId: 'osx-x64',
+        archiveType: 'tar.gz',
+        binaryName: 'dotnet'
+    },
+    {
+        id: 'DotNetRuntime',
+        url: 'https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.6/dotnet-runtime-9.0.6-osx-arm64.tar.gz',
+        platformId: 'osx-arm64',
+        archiveType: 'tar.gz',
+        binaryName: 'dotnet'
+    }
+];
+const CSHARP_IGNORED_DIRECTORIES = new Set(['bin', 'obj', 'packages', '.vs']);
+export class CSharpLanguageServer extends SolidLanguageServer {
+    handler;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredDirectories(config.ignoredPaths)
+        };
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const runtimeDir = resolveRuntimeDirectory(solidSettings);
+        const languageSettings = normalizeLanguageSettings(solidSettings.lsSpecificSettings?.[Language.CSHARP]);
+        const { logger: installLogger } = createSerenaLogger({
+            name: 'solidlsp.language_servers.csharp',
+            emitToConsole: false,
+            level: loggerLike?.level === undefined ? undefined : coerceLogLevel(loggerLike.level)
+        });
+        const { dotnetPath, languageServerPath } = ensureRuntimeAssets({
+            runtimeDir,
+            logger: installLogger,
+            overrides: languageSettings.runtime_dependencies ?? [],
+            dotnetRuntimeUrlOverride: languageSettings.dotnet_runtime_url
+        });
+        const logDir = path.join(runtimeDir, 'logs');
+        fs.mkdirSync(logDir, { recursive: true });
+        const processInfo = {
+            cmd: buildCommand(dotnetPath, languageServerPath, logDir),
+            cwd: repositoryRootPath
+        };
+        const handler = new NodeLanguageServerHandler(processInfo, {
+            requestTimeoutSeconds: options?.timeout ?? null
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.handler = handler;
+        this.registerHandlers();
+    }
+    start() {
+        const shouldInitialize = !this.initialized;
+        super.start();
+        if (shouldInitialize) {
+            this.initializeLanguageServer();
+            this.initialized = true;
+        }
+        return this;
+    }
+    stop(shutdownTimeout = 2.0) {
+        super.stop(shutdownTimeout);
+        this.initialized = false;
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.handler.onNotification('window/logMessage', (payload) => {
+            const message = extractLogMessage(payload);
+            if (message) {
+                this.logger.info(`C# LS: ${message}`);
+            }
+        });
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+        this.handler.onRequest('workspace/configuration', (params) => {
+            const items = params?.items;
+            return Array.isArray(items) ? items.map(() => ({})) : [];
+        });
+        this.handler.onRequest('window/workDoneProgress/create', noop);
+        this.handler.onRequest('client/registerCapability', () => []);
+        this.handler.onRequest('workspace/_roslyn_projectNeedsRestore', noop);
+    }
+    initializeLanguageServer() {
+        const params = this.buildInitializeParams();
+        const response = this.handler.sendRequest('initialize', params);
+        if (!response || typeof response !== 'object') {
+            throw new Error('C# language server returned an invalid initialize response.');
+        }
+        this.applyDiagnosticCapabilities(response);
+        this.verifyCapabilities(response.capabilities ?? null);
+        this.handler.notify.initialized({});
+        this.openSolutionAndProjects();
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ],
+            processId: process.pid,
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            capabilities: buildClientCapabilities()
+        };
+    }
+    applyDiagnosticCapabilities(response) {
+        if (!isRecord(response.capabilities)) {
+            return;
+        }
+        const capabilities = response.capabilities;
+        const diagnosticProvider = capabilities.diagnosticProvider;
+        if (diagnosticProvider && typeof diagnosticProvider === 'object') {
+            Object.assign(diagnosticProvider, {
+                interFileDependencies: true,
+                workDoneProgress: true,
+                workspaceDiagnostics: true
+            });
+        }
+        else {
+            capabilities.diagnosticProvider = {
+                interFileDependencies: true,
+                workDoneProgress: true,
+                workspaceDiagnostics: true
+            };
+        }
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('C# language server initialization response is missing capabilities.');
+        }
+        const required = ['textDocumentSync', 'definitionProvider', 'referencesProvider', 'documentSymbolProvider'];
+        const missing = required.filter((key) => !(key in capabilities));
+        if (missing.length > 0) {
+            throw new Error(`C# language server is missing required capabilities: ${missing.join(', ')}. Ensure Microsoft.CodeAnalysis.LanguageServer is installed.`);
+        }
+    }
+    openSolutionAndProjects() {
+        const solutionFile = findSolutionOrProjectFile(this.repositoryRootPath, '.sln');
+        if (solutionFile) {
+            const solutionUri = pathToFileURL(solutionFile).href;
+            this.handler.sendNotification('solution/open', { solution: solutionUri });
+            this.logger.info(`Opened solution file: ${solutionFile}`);
+        }
+        const projectFiles = findAllProjectFiles(this.repositoryRootPath, '.csproj');
+        if (projectFiles.length > 0) {
+            const projectUris = projectFiles.map((project) => pathToFileURL(project).href);
+            this.handler.sendNotification('project/open', { projects: projectUris });
+            this.logger.debug(`Opened project files: ${projectFiles.join(', ')}`);
+        }
+    }
+}
+registerLanguageServer(Language.CSHARP, CSharpLanguageServer);
+function ensureRuntimeAssets(options) {
+    const { runtimeDir, logger, overrides, dotnetRuntimeUrlOverride } = options;
+    const dotnetDir = path.join(runtimeDir, 'dotnet-runtime-9.0');
+    const languageServerDir = path.join(runtimeDir, 'language-server');
+    const dotnetDependency = resolveDependency('DotNetRuntime', overrides);
+    const languageDependency = resolveDependency('CSharpLanguageServer', overrides);
+    const dotnetPath = ensureDotnetRuntime({
+        logger,
+        targetDir: dotnetDir,
+        dependency: applyUrlOverride(dotnetDependency, dotnetRuntimeUrlOverride)
+    });
+    const languageServerPath = ensureLanguageServer({
+        logger,
+        targetDir: languageServerDir,
+        dependency: languageDependency
+    });
+    return { dotnetPath, languageServerPath };
+}
+function ensureDotnetRuntime(options) {
+    const { logger, targetDir, dependency } = options;
+    const systemDotnet = findDotnetRuntimeFromSystem(logger);
+    if (systemDotnet) {
+        return systemDotnet;
+    }
+    const binaryPath = path.join(targetDir, dependency.binaryName ?? inferDotnetBinaryName());
+    if (fs.existsSync(binaryPath)) {
+        return binaryPath;
+    }
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        throw new Error(`dotnet runtime was not found at ${binaryPath}. Set SERENA_SKIP_RUNTIME_INSTALL=0 to allow downloads or place dotnet manually.`);
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+    logger.info('Downloading .NET runtime for C# language server.');
+    const collection = new RuntimeDependencyCollection([dependency]);
+    collection.install(logger, targetDir);
+    if (!fs.existsSync(binaryPath)) {
+        throw new Error(`dotnet binary not found after installation (expected at ${binaryPath}).`);
+    }
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(binaryPath, 0o755);
+        }
+        catch {
+            // best effort
+        }
+    }
+    return binaryPath;
+}
+function ensureLanguageServer(options) {
+    const { logger, targetDir, dependency } = options;
+    const version = dependency.packageVersion ?? 'unknown';
+    const packageName = dependency.packageName ?? 'Microsoft.CodeAnalysis.LanguageServer';
+    const installationDir = path.join(targetDir, `${packageName}.${version}`);
+    const dllPath = path.join(installationDir, dependency.binaryName ?? 'Microsoft.CodeAnalysis.LanguageServer.dll');
+    if (fs.existsSync(dllPath)) {
+        return dllPath;
+    }
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        throw new Error(`C# language server DLL not found at ${dllPath}. Allow downloads or place Microsoft.CodeAnalysis.LanguageServer manually.`);
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'serena-csharp-ls-'));
+    try {
+        const extractDir = path.join(tempDir, 'extracted');
+        fs.mkdirSync(extractDir, { recursive: true });
+        const packagePath = downloadNugetPackage({
+            logger,
+            dependency,
+            extractDir
+        });
+        copyDependencyPayload({
+            dependency,
+            packageRoot: packagePath,
+            targetDir: installationDir
+        });
+    }
+    finally {
+        safeRemove(tempDir);
+    }
+    if (!fs.existsSync(dllPath)) {
+        throw new Error(`Microsoft.CodeAnalysis.LanguageServer.dll not found after extraction (expected at ${dllPath}).`);
+    }
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(dllPath, 0o755);
+        }
+        catch {
+            // ignore chmod errors
+        }
+    }
+    return dllPath;
+}
+function downloadNugetPackage(options) {
+    const { logger, dependency, extractDir } = options;
+    const packageName = dependency.packageName;
+    const packageVersion = dependency.packageVersion;
+    if (!packageName || !packageVersion) {
+        throw new Error('C# language server dependency must specify packageName and packageVersion.');
+    }
+    const serviceIndex = downloadServiceIndex(logger);
+    const baseAddress = findPackageBaseAddress(serviceIndex);
+    const packageUrl = buildPackageUrl(baseAddress, packageName, packageVersion);
+    const archivePath = path.join(extractDir, `${packageName}.${packageVersion}.nupkg`);
+    downloadWithCurl(packageUrl, archivePath, logger);
+    const packageRoot = path.join(extractDir, `${packageName}.${packageVersion}`);
+    fs.mkdirSync(packageRoot, { recursive: true });
+    extractZipArchive(archivePath, packageRoot);
+    return packageRoot;
+}
+function downloadServiceIndex(logger) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'serena-nuget-index-'));
+    const indexPath = path.join(tempDir, 'index.json');
+    try {
+        downloadWithCurl(NUGET_SERVICE_INDEX, indexPath, logger);
+        const data = fs.readFileSync(indexPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    finally {
+        safeRemove(tempDir);
+    }
+}
+function findPackageBaseAddress(serviceIndex) {
+    if (!serviceIndex || typeof serviceIndex !== 'object') {
+        throw new Error('Invalid NuGet service index payload.');
+    }
+    const resources = serviceIndex.resources;
+    if (!Array.isArray(resources)) {
+        throw new Error('NuGet service index is missing resources array.');
+    }
+    for (const entry of resources) {
+        const baseAddress = entry?.['@id'];
+        if (entry?.['@type'] === 'PackageBaseAddress/3.0.0' && typeof baseAddress === 'string') {
+            return baseAddress;
+        }
+    }
+    throw new Error('Failed to locate NuGet PackageBaseAddress in service index.');
+}
+function buildPackageUrl(baseAddress, packageName, packageVersion) {
+    const lowerName = packageName.toLowerCase();
+    const lowerVersion = packageVersion.toLowerCase();
+    return `${baseAddress.replace(/\/?$/, '/')}${lowerName}/${lowerVersion}/${lowerName}.${lowerVersion}.nupkg`;
+}
+function copyDependencyPayload(options) {
+    const { dependency, packageRoot, targetDir } = options;
+    const extractPath = dependency.extractPath ?? 'lib/net9.0';
+    const primaryPath = path.join(packageRoot, extractPath);
+    const fallbackLocations = [
+        path.join(packageRoot, 'tools', 'net9.0', 'any'),
+        path.join(packageRoot, 'lib', 'net9.0'),
+        path.join(packageRoot, 'contentFiles', 'any', 'net9.0')
+    ];
+    const candidates = [primaryPath, ...fallbackLocations];
+    const existing = candidates.find((candidate) => fs.existsSync(candidate));
+    if (!existing) {
+        throw new Error(`Could not locate language server payload inside ${packageRoot}.`);
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+    copyDirectory(existing, targetDir);
+}
+function mergeIgnoredDirectories(existing) {
+    const set = new Set(existing ?? []);
+    for (const entry of CSHARP_IGNORED_DIRECTORIES) {
+        set.add(entry);
+        set.add(`**/${entry}`);
+    }
+    return Array.from(set);
+}
+function resolveRuntimeDirectory(settings) {
+    const dir = path.join(settings.languageServersStaticDir, 'csharp');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function normalizeLanguageSettings(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return {};
+    }
+    const settings = raw;
+    const runtimeOverrides = [];
+    const maybeOverrides = settings.runtime_dependencies;
+    if (Array.isArray(maybeOverrides)) {
+        for (const entry of maybeOverrides) {
+            if (entry && typeof entry === 'object') {
+                runtimeOverrides.push(entry);
+            }
+        }
+    }
+    return {
+        runtime_dependencies: runtimeOverrides,
+        dotnet_runtime_url: typeof settings.dotnet_runtime_url === 'string' ? settings.dotnet_runtime_url : undefined
+    };
+}
+function resolveDependency(id, overrides) {
+    const platform = currentPlatformId();
+    const candidates = RUNTIME_DEPENDENCIES.filter((entry) => entry.id === id && matchesPlatform(entry.platformId, platform));
+    if (candidates.length === 0) {
+        throw new Error(`No runtime dependency found for ${id} on platform ${platform ?? 'unknown'}.`);
+    }
+    const base = { ...candidates[0] };
+    const override = overrides.find((entry) => entry.id === id && matchesPlatform(entry.platformId, platform));
+    return override ? { ...base, ...override } : base;
+}
+function matchesPlatform(candidate, platform) {
+    if (!candidate || candidate === 'any' || candidate === 'platform-agnostic') {
+        return true;
+    }
+    if (!platform) {
+        return false;
+    }
+    return candidate.toLowerCase() === platform.toLowerCase();
+}
+function currentPlatformId() {
+    if (process.platform === 'win32') {
+        return process.arch === 'arm64' ? 'win-arm64' : 'win-x64';
+    }
+    if (process.platform === 'darwin') {
+        return process.arch === 'arm64' ? 'osx-arm64' : 'osx-x64';
+    }
+    if (process.platform === 'linux') {
+        if (process.arch === 'arm64') {
+            return 'linux-arm64';
+        }
+        return 'linux-x64';
+    }
+    return null;
+}
+function findDotnetRuntimeFromSystem(logger) {
+    const dotnetPath = whichBinary('dotnet');
+    if (!dotnetPath) {
+        return null;
+    }
+    const result = spawnSync(dotnetPath, ['--list-runtimes'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status === 0 && typeof result.stdout === 'string' && result.stdout.includes('Microsoft.NETCore.App 9.')) {
+        logger.info('Found system .NET 9 runtime.');
+        return dotnetPath;
+    }
+    return null;
+}
+function whichBinary(command) {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(locator, [command], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status === 0 && typeof result.stdout === 'string') {
+        const [first] = result.stdout.split(/\r?\n/);
+        if (first && first.trim().length > 0) {
+            return first.trim();
+        }
+    }
+    return null;
+}
+function inferDotnetBinaryName() {
+    return process.platform === 'win32' ? 'dotnet.exe' : 'dotnet';
+}
+function buildCommand(dotnetPath, languageServerPath, logDir) {
+    return [
+        dotnetPath,
+        languageServerPath,
+        '--logLevel=Information',
+        `--extensionLogDirectory=${quoteForArgument(logDir)}`,
+        '--stdio'
+    ];
+}
+function extractLogMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const value = payload.message;
+    return typeof value === 'string' ? value : null;
+}
+function downloadWithCurl(url, destination, logger) {
+    logger.info(`Downloading ${url}`);
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    const args = ['-L', url, '-o', destination];
+    const result = spawnSync('curl', args, ensureDefaultSubprocessOptions({ stdio: 'inherit' }));
+    if (result.status === 0) {
+        return;
+    }
+    if (process.platform !== 'win32') {
+        const wget = spawnSync('wget', ['-O', destination, url], ensureDefaultSubprocessOptions({ stdio: 'inherit' }));
+        if (wget.status === 0) {
+            return;
+        }
+    }
+    else {
+        const ps = spawnSync('powershell', [
+            '-NoLogo',
+            '-NoProfile',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-Command',
+            `Invoke-WebRequest -Uri ${JSON.stringify(url)} -OutFile ${JSON.stringify(destination)} -UseBasicParsing`
+        ], ensureDefaultSubprocessOptions({ stdio: 'inherit' }));
+        if (ps.status === 0) {
+            return;
+        }
+    }
+    throw new Error(`Failed to download ${url}. Ensure curl, wget, or PowerShell is available.`);
+}
+function extractZipArchive(archivePath, targetDir) {
+    const extractor = new SafeZipExtractor(archivePath, targetDir, { verbose: false });
+    extractor.extractAll();
+}
+function copyDirectory(source, destination) {
+    fs.mkdirSync(destination, { recursive: true });
+    const entries = fs.readdirSync(source, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = path.join(source, entry.name);
+        const destinationPath = path.join(destination, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectory(sourcePath, destinationPath);
+        }
+        else if (entry.isFile()) {
+            fs.copyFileSync(sourcePath, destinationPath);
+            if (process.platform !== 'win32') {
+                try {
+                    fs.chmodSync(destinationPath, 0o755);
+                }
+                catch {
+                    // ignore chmod failures
+                }
+            }
+        }
+    }
+}
+function safeRemove(targetPath) {
+    try {
+        fs.rmSync(targetPath, { recursive: true, force: true });
+    }
+    catch {
+        // best effort cleanup
+    }
+}
+function buildClientCapabilities() {
+    const valueSet = Array.from({ length: 27 }, (_, index) => index + 1);
+    return {
+        window: {
+            workDoneProgress: true,
+            showMessage: { messageActionItem: { additionalPropertiesSupport: true } },
+            showDocument: { support: true }
+        },
+        workspace: {
+            applyEdit: true,
+            workspaceEdit: { documentChanges: true },
+            didChangeConfiguration: { dynamicRegistration: true },
+            didChangeWatchedFiles: { dynamicRegistration: true },
+            symbol: {
+                dynamicRegistration: true,
+                symbolKind: { valueSet }
+            },
+            executeCommand: { dynamicRegistration: true }
+        },
+        textDocument: {
+            synchronization: {
+                dynamicRegistration: true,
+                willSave: true,
+                willSaveWaitUntil: true,
+                didSave: true
+            },
+            hover: {
+                dynamicRegistration: true,
+                contentFormat: ['markdown', 'plaintext']
+            },
+            signatureHelp: {
+                dynamicRegistration: true,
+                signatureInformation: {
+                    documentationFormat: ['markdown', 'plaintext'],
+                    parameterInformation: { labelOffsetSupport: true }
+                }
+            },
+            definition: { dynamicRegistration: true },
+            references: { dynamicRegistration: true },
+            documentSymbol: {
+                dynamicRegistration: true,
+                hierarchicalDocumentSymbolSupport: true,
+                symbolKind: { valueSet }
+            }
+        }
+    };
+}
+function findSolutionOrProjectFile(rootDir, extension) {
+    for (const candidate of breadthFirstFileScan(rootDir)) {
+        if (candidate.toLowerCase().endsWith(extension.toLowerCase())) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function findAllProjectFiles(rootDir, extension) {
+    const results = [];
+    for (const candidate of breadthFirstFileScan(rootDir)) {
+        if (candidate.toLowerCase().endsWith(extension.toLowerCase())) {
+            results.push(candidate);
+        }
+    }
+    return results;
+}
+function* breadthFirstFileScan(rootDir) {
+    const queue = [rootDir];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            const candidatePath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(candidatePath);
+            }
+            else if (entry.isFile()) {
+                yield candidatePath;
+            }
+        }
+    }
+}
+function applyUrlOverride(dep, overrideUrl) {
+    if (!overrideUrl) {
+        return dep;
+    }
+    return { ...dep, url: overrideUrl };
+}
+function quoteForArgument(value) {
+    if (/\s/.test(value)) {
+        return `"${value}"`;
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}