@nogataka/smart-edit 0.0.14

package/dist/solidlsp/language_servers/typescript_language_server.js

@@ -0,0 +1,237 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+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 } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { Platform, RuntimeDependencyCollection, quoteWindowsPath } from './common.js';
+const TYPESCRIPT_IGNORED_PATTERNS = ['**/node_modules', '**/dist', '**/build', '**/coverage'];
+export class TypeScriptLanguageServer extends SolidLanguageServer {
+    nodeHandler;
+    initialized = false;
+    serverReady = false;
+    initializeCommandRegistered = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, TYPESCRIPT_IGNORED_PATTERNS)
+        };
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const launchInfo = determineLaunchInfo(solidSettings);
+        const handler = new NodeLanguageServerHandler({
+            ...launchInfo,
+            cwd: repositoryRootPath
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.nodeHandler = handler;
+        this.registerHandlers();
+    }
+    start() {
+        const shouldInitialize = !this.initialized;
+        super.start();
+        if (shouldInitialize) {
+            this.serverReady = false;
+            this.initializeCommandRegistered = false;
+            this.initializeLanguageServer();
+            this.initialized = true;
+        }
+        return this;
+    }
+    stop(shutdownTimeout = 2.0) {
+        super.stop(shutdownTimeout);
+        this.initialized = false;
+        this.serverReady = false;
+        this.initializeCommandRegistered = false;
+    }
+    registerHandlers() {
+        this.nodeHandler.onRequest('client/registerCapability', (params) => {
+            const registrations = params?.registrations;
+            if (!Array.isArray(registrations)) {
+                return null;
+            }
+            for (const registration of registrations) {
+                if (registration?.method === 'workspace/executeCommand') {
+                    this.initializeCommandRegistered = true;
+                }
+            }
+            return null;
+        });
+        this.nodeHandler.onRequest('workspace/executeClientCommand', () => []);
+        const noop = () => undefined;
+        this.nodeHandler.onNotification('$/progress', noop);
+        this.nodeHandler.onNotification('textDocument/publishDiagnostics', noop);
+        this.nodeHandler.onNotification('window/logMessage', (payload) => {
+            const message = extractMessage(payload);
+            if (message) {
+                this.logger.info(`TypeScript LS: ${message}`);
+            }
+        });
+        this.nodeHandler.onNotification('experimental/serverStatus', (payload) => {
+            const params = payload;
+            if (params?.quiescent) {
+                this.serverReady = true;
+            }
+        });
+    }
+    initializeLanguageServer() {
+        const params = this.buildInitializeParams();
+        const response = this.nodeHandler.sendRequest('initialize', params);
+        if (!response || typeof response !== 'object') {
+            throw new Error('TypeScript language server returned an invalid initialize response.');
+        }
+        this.verifyCapabilities(response.capabilities ?? null);
+        this.nodeHandler.notify.initialized({});
+        if (!this.serverReady) {
+            this.logger.debug('TypeScript language server did not report readiness before timeout; continuing.');
+        }
+        if (!this.initializeCommandRegistered) {
+            this.logger.debug('TypeScript language server did not register workspace/executeCommand capability during initialization.');
+        }
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            locale: 'en',
+            capabilities: {
+                textDocument: {
+                    synchronization: { didSave: true, dynamicRegistration: true },
+                    completion: {
+                        dynamicRegistration: true,
+                        completionItem: { snippetSupport: true }
+                    },
+                    definition: { dynamicRegistration: true },
+                    references: { dynamicRegistration: true },
+                    documentSymbol: {
+                        dynamicRegistration: true,
+                        hierarchicalDocumentSymbolSupport: true,
+                        symbolKind: { valueSet: rangeArray(1, 27) }
+                    },
+                    hover: {
+                        dynamicRegistration: true,
+                        contentFormat: ['markdown', 'plaintext']
+                    },
+                    signatureHelp: { dynamicRegistration: true },
+                    codeAction: { dynamicRegistration: true }
+                },
+                workspace: {
+                    workspaceFolders: true,
+                    didChangeConfiguration: { dynamicRegistration: true },
+                    symbol: { dynamicRegistration: true }
+                }
+            },
+            processId: process.pid,
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('TypeScript initialization response is missing capabilities.');
+        }
+        const textDocumentSync = capabilities.textDocumentSync;
+        const completionProvider = capabilities.completionProvider;
+        if (textDocumentSync !== 2) {
+            throw new Error('TypeScript language server must provide incremental textDocumentSync (value 2).');
+        }
+        if (!completionProvider || typeof completionProvider !== 'object') {
+            throw new Error('TypeScript language server does not expose completionProvider capability.');
+        }
+    }
+}
+function determineLaunchInfo(settings) {
+    const { logger } = createSerenaLogger({
+        name: 'solidlsp.language_servers.typescript',
+        emitToConsole: false
+    });
+    const runtimeDir = resolveRuntimeDirectory(settings);
+    let localBinary = null;
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL !== '1') {
+        assertBinaryAvailable('node');
+        assertBinaryAvailable('npm');
+        const dependencies = new RuntimeDependencyCollection([
+            {
+                id: 'typescript',
+                description: 'typescript npm package',
+                command: ['npm', 'install', '--prefix', './', 'typescript@5.5.4'],
+                platformId: 'any'
+            },
+            {
+                id: 'typescript-language-server',
+                description: 'typescript-language-server npm package',
+                command: ['npm', 'install', '--prefix', './', 'typescript-language-server@4.3.3'],
+                platformId: 'any'
+            }
+        ]);
+        try {
+            dependencies.install(logger, runtimeDir);
+        }
+        catch (error) {
+            logger.warn(`Failed to install TypeScript language server dependencies: ${String(error)}`);
+        }
+    }
+    const binName = Platform.isWindows() ? 'typescript-language-server.cmd' : 'typescript-language-server';
+    localBinary = locateLocalBinary(runtimeDir, binName);
+    if (localBinary) {
+        return { cmd: `${quoteWindowsPath(localBinary)} --stdio` };
+    }
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        return { cmd: 'typescript-language-server --stdio' };
+    }
+    throw new Error(`typescript-language-server executable not found in ${runtimeDir}.`);
+}
+function locateLocalBinary(runtimeDir, binaryName) {
+    const candidate = path.join(runtimeDir, 'node_modules', '.bin', binaryName);
+    if (fs.existsSync(candidate)) {
+        return candidate;
+    }
+    return null;
+}
+function resolveRuntimeDirectory(settings) {
+    const dir = path.join(settings.languageServersStaticDir, 'TypeScriptLanguageServer');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function assertBinaryAvailable(command) {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(locator, [command], ensureDefaultSubprocessOptions({
+        stdio: 'ignore'
+    }));
+    if (result.status !== 0) {
+        throw new Error(`${command} is not installed or not available in PATH.`);
+    }
+}
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+    }
+    return Array.from(merged);
+}
+function extractMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const message = payload.message;
+    return typeof message === 'string' ? message : null;
+}
+function rangeArray(start, endExclusive) {
+    const values = [];
+    for (let value = start; value < endExclusive; value += 1) {
+        values.push(value);
+    }
+    return values;
+}
+registerLanguageServer(Language.TYPESCRIPT, TypeScriptLanguageServer);

package/dist/solidlsp/language_servers/vts_language_server.d.ts

@@ -0,0 +1,13 @@
+import { type LogLevel } from '../../serena/util/logging.js';
+import { SolidLanguageServer, type LanguageServerConfigLike, type SolidLspSettingsInit } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+export declare class VtsLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: number | LogLevel;
+    } | null, repositoryRootPath: string, options?: {
+        timeout?: number | null;
+        solidlspSettings?: SolidLspSettingsInit;
+    });
+    private registerHandlers;
+}

package/dist/solidlsp/language_servers/vts_language_server.js

@@ -0,0 +1,121 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+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, quoteWindowsPath } from './common.js';
+const VTS_DEPENDENCIES = [
+    {
+        id: 'vtsls',
+        command: 'npm install --prefix ./ @vtsls/language-server@0.2.9',
+        platformId: 'any'
+    }
+];
+function commandExists(command) {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    return spawnSync(locator, [command], ensureDefaultSubprocessOptions({ stdio: 'ignore' })).status === 0;
+}
+function ensureNodeTooling() {
+    if (process.env.SERENA_ASSUME_VTSLS === '1') {
+        return;
+    }
+    if (!commandExists('node')) {
+        throw new Error('Node.js is not installed or not in PATH. Install it from https://nodejs.org/ and retry.');
+    }
+    if (!commandExists('npm')) {
+        throw new Error('npm is not installed or not in PATH. Install npm (bundled with Node.js) and retry.');
+    }
+}
+function resolveRuntimeDirectory(settings) {
+    const dir = path.join(settings.languageServersStaticDir, 'vts-lsp');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function resolveBinaryPath(runtimeDir) {
+    const base = path.join(runtimeDir, 'node_modules', '.bin');
+    if (process.platform === 'win32') {
+        const cmdPath = path.join(base, 'vtsls.cmd');
+        if (fs.existsSync(cmdPath)) {
+            return cmdPath;
+        }
+        const ps1Path = path.join(base, 'vtsls.ps1');
+        if (fs.existsSync(ps1Path)) {
+            return ps1Path;
+        }
+    }
+    return path.join(base, 'vtsls');
+}
+function ensureVtslsBinary(runtimeDir, dependencies, loggerLevel) {
+    const { logger } = createSerenaLogger({
+        name: 'solidlsp.language_servers.vtsls',
+        emitToConsole: false,
+        level: loggerLevel === undefined ? undefined : coerceLogLevel(loggerLevel)
+    });
+    const binaryPath = resolveBinaryPath(runtimeDir);
+    if (fs.existsSync(binaryPath)) {
+        return binaryPath;
+    }
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        throw new Error(`vtsls executable not found at ${binaryPath}. Allow downloads or install @vtsls/language-server manually.`);
+    }
+    ensureNodeTooling();
+    logger.info('Installing @vtsls/language-server via npm');
+    dependencies.install(logger, runtimeDir);
+    if (!fs.existsSync(binaryPath)) {
+        throw new Error(`@vtsls/language-server installation completed but executable missing at ${binaryPath}. Verify npm installation succeeded.`);
+    }
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(binaryPath, 0o755);
+        }
+        catch {
+            // ignore chmod failures
+        }
+    }
+    return binaryPath;
+}
+function mergeIgnoredPaths(existing) {
+    const merged = new Set(existing ?? []);
+    ['node_modules', 'dist', 'build', 'coverage'].forEach((entry) => merged.add(entry));
+    return Array.from(merged);
+}
+export class VtsLanguageServer extends SolidLanguageServer {
+    handler;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths)
+        };
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const runtimeDir = resolveRuntimeDirectory(solidSettings);
+        const dependencies = new RuntimeDependencyCollection(VTS_DEPENDENCIES);
+        const binaryPath = ensureVtslsBinary(runtimeDir, dependencies, loggerLike?.level);
+        const handler = new NodeLanguageServerHandler({
+            cmd: `${quoteWindowsPath(binaryPath)} --stdio`,
+            cwd: repositoryRootPath
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.handler = handler;
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.handler.onNotification('window/logMessage', (payload) => {
+            if (payload && typeof payload === 'object' && 'message' in payload) {
+                this.logger.info(`vtsls: ${payload.message ?? ''}`);
+            }
+        });
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onRequest('workspace/executeClientCommand', () => []);
+    }
+}
+registerLanguageServer(Language.TYPESCRIPT_VTS, VtsLanguageServer);

package/dist/solidlsp/language_servers/zls.d.ts

@@ -0,0 +1,20 @@
+import type { LogLevel } from '../../serena/util/logging.js';
+import { SolidLanguageServer, type LanguageServerConfigLike, type SolidLspSettingsInit } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+export declare class ZigLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    private initialized;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: number | LogLevel;
+    } | null, repositoryRootPath: string, options?: {
+        timeout?: number | null;
+        solidlspSettings?: SolidLspSettingsInit;
+    });
+    start(): this;
+    stop(shutdownTimeout?: number): void;
+    private registerHandlers;
+    private initializeLanguageServer;
+    private buildInitializeParams;
+    private verifyCapabilities;
+    private openBuildFileIfPresent;
+}

package/dist/solidlsp/language_servers/zls.js

@@ -0,0 +1,254 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDefaultSubprocessOptions } from '../util/subprocess_util.js';
+import { Language } from '../ls_config.js';
+import { SolidLanguageServer, registerLanguageServer } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { quoteWindowsPath } from './common.js';
+const ZLS_ASSUME_ENV = 'SERENA_ASSUME_ZLS';
+const ZLS_PATH_ENV = 'SERENA_ZLS_PATH';
+const ZIG_PATH_ENV = 'SERENA_ZIG_PATH';
+const WINDOWS_UNSUPPORTED_MESSAGE = 'Windows is not supported by the Zig Language Server integration. Cross-file references are unreliable on Windows.';
+const ZIG_IGNORED_DIRECTORIES = ['zig-cache', '.zig-cache', 'zig-out', 'node_modules', 'build', 'dist'];
+export class ZigLanguageServer extends SolidLanguageServer {
+    handler;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, ZIG_IGNORED_DIRECTORIES)
+        };
+        const binaryPath = ensureZlsRuntime();
+        const handler = new NodeLanguageServerHandler({
+            cmd: [quoteWindowsPath(binaryPath)],
+            cwd: repositoryRootPath
+        });
+        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.onRequest('client/registerCapability', noop);
+        this.handler.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`zls: ${message}`);
+            }
+        });
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+    }
+    initializeLanguageServer() {
+        const params = this.buildInitializeParams();
+        const response = this.handler.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.handler.notify.initialized({});
+        this.openBuildFileIfPresent();
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            processId: process.pid,
+            locale: 'en',
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            capabilities: buildClientCapabilities(),
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ],
+            initializationOptions: buildInitializationOptions()
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('Zig language server initialize response is missing capabilities.');
+        }
+        const subset = capabilities;
+        for (const key of ['textDocumentSync', 'definitionProvider', 'documentSymbolProvider', 'referencesProvider']) {
+            if (!(key in subset)) {
+                throw new Error(`Zig language server did not advertise required capability '${key}'.`);
+            }
+        }
+    }
+    openBuildFileIfPresent() {
+        const buildFilePath = path.join(this.repositoryRootPath, 'build.zig');
+        if (!fs.existsSync(buildFilePath)) {
+            return;
+        }
+        try {
+            const contents = fs.readFileSync(buildFilePath, { encoding: 'utf-8' });
+            const uri = pathToFileURL(buildFilePath).href;
+            this.handler.notify.didOpenTextDocument({
+                textDocument: {
+                    uri,
+                    languageId: 'zig',
+                    version: 1,
+                    text: contents
+                }
+            });
+            this.logger.info('Opened build.zig to seed Zig language server project context.');
+        }
+        catch (error) {
+            this.logger.warn(`Failed to open build.zig: ${error.message}`);
+        }
+    }
+}
+registerLanguageServer(Language.ZIG, ZigLanguageServer);
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+    }
+    return Array.from(merged);
+}
+function ensureZlsRuntime() {
+    if (process.env[ZLS_ASSUME_ENV] === '1') {
+        const override = process.env[ZLS_PATH_ENV];
+        if (override && override.length > 0) {
+            return override;
+        }
+        return process.platform === 'win32' ? 'zls.exe' : 'zls';
+    }
+    if (process.platform === 'win32') {
+        throw new Error(WINDOWS_UNSUPPORTED_MESSAGE);
+    }
+    const zigPath = resolveZigExecutable();
+    if (!zigPath || !detectZigVersion(zigPath)) {
+        throw new Error('Zig is not installed. Install Zig from https://ziglang.org/download/ and ensure it is available in PATH.');
+    }
+    const zlsExecutable = resolveZlsExecutable();
+    if (!zlsExecutable) {
+        throw new Error('Found Zig but ZLS (Zig Language Server) is not installed. Install it via package managers or from https://github.com/zigtools/zls and ensure `zls` is on PATH.');
+    }
+    return zlsExecutable;
+}
+function resolveZigExecutable() {
+    const override = process.env[ZIG_PATH_ENV];
+    if (override && fs.existsSync(override)) {
+        return override;
+    }
+    const binaryName = process.platform === 'win32' ? 'zig.exe' : 'zig';
+    const located = which(binaryName);
+    if (located && fs.existsSync(located)) {
+        return located;
+    }
+    return null;
+}
+function detectZigVersion(executable) {
+    const result = spawnSync(executable, ['version'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status === 0 && typeof result.stdout === 'string') {
+        const trimmed = result.stdout.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    return null;
+}
+function resolveZlsExecutable() {
+    const override = process.env[ZLS_PATH_ENV];
+    if (override && fs.existsSync(override)) {
+        return override;
+    }
+    const binaryName = process.platform === 'win32' ? 'zls.exe' : 'zls';
+    const located = which(binaryName);
+    if (located && fs.existsSync(located)) {
+        return located;
+    }
+    return null;
+}
+function which(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') {
+        return null;
+    }
+    const lines = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    return lines[0] ?? null;
+}
+function extractWindowMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const message = payload.message;
+    return typeof message === 'string' ? message : null;
+}
+function buildClientCapabilities() {
+    const symbolKinds = Array.from({ length: 26 }, (_, index) => index + 1);
+    return {
+        textDocument: {
+            synchronization: { didSave: true, dynamicRegistration: true },
+            definition: { dynamicRegistration: true },
+            references: { dynamicRegistration: true },
+            documentSymbol: {
+                dynamicRegistration: true,
+                hierarchicalDocumentSymbolSupport: true,
+                symbolKind: { valueSet: symbolKinds }
+            },
+            completion: {
+                dynamicRegistration: true,
+                completionItem: {
+                    snippetSupport: true,
+                    commitCharactersSupport: true,
+                    documentationFormat: ['markdown', 'plaintext'],
+                    deprecatedSupport: true,
+                    preselectSupport: true
+                }
+            },
+            hover: {
+                dynamicRegistration: true,
+                contentFormat: ['markdown', 'plaintext']
+            }
+        },
+        workspace: {
+            workspaceFolders: true,
+            didChangeConfiguration: { dynamicRegistration: true },
+            configuration: true
+        }
+    };
+}
+function buildInitializationOptions() {
+    return {
+        zig_exe_path: resolveZigExecutable(),
+        zig_lib_path: null,
+        build_runner_path: null,
+        global_cache_path: null,
+        enable_build_on_save: true,
+        build_on_save_args: ['build'],
+        enable_snippets: true,
+        enable_argument_placeholders: true,
+        semantic_tokens: 'full',
+        warn_style: false,
+        highlight_global_var_declarations: false,
+        skip_std_references: false,
+        prefer_ast_check_as_child_process: true,
+        completion_label_details: true,
+        inlay_hints_show_variable_type_hints: true,
+        inlay_hints_show_struct_literal_field_type: true,
+        inlay_hints_show_parameter_name: true,
+        inlay_hints_show_builtin: true,
+        inlay_hints_exclude_single_argument: true,
+        inlay_hints_hide_redundant_param_names: false,
+        inlay_hints_hide_redundant_param_names_last_token: false
+    };
+}