@nogataka/smart-edit 0.0.14

package/dist/solidlsp/language_servers/ruby_lsp.js

@@ -0,0 +1,230 @@
+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 { SolidLanguageServer, registerLanguageServer, coerceLogLevel } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { buildRubyExcludePatterns, ensureRubyAvailable, findBundleExecutable, findCommand, gemfileLockContains, installGem } from './ruby_common.js';
+const RUBY_LSP_ASSUME_ENV = 'SERENA_ASSUME_RUBY_LSP';
+const RUBY_LSP_PATH_ENV = 'SERENA_RUBY_LSP_PATH';
+const RUBY_LSP_LOGGER_NAME = 'solidlsp.language_servers.ruby_lsp';
+const DEFAULT_REQUEST_TIMEOUT = 30; // seconds
+const RUBY_IGNORED_DIRECTORIES = [
+    'vendor',
+    '.bundle',
+    'tmp',
+    'log',
+    'coverage',
+    '.yardoc',
+    'doc',
+    'node_modules',
+    'storage',
+    'public/packs',
+    'public/webpack',
+    'public/assets'
+];
+export class RubyLspLanguageServer extends SolidLanguageServer {
+    handlerInstance;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, RUBY_IGNORED_DIRECTORIES)
+        };
+        const { logger: runtimeLogger } = createSerenaLogger({
+            name: RUBY_LSP_LOGGER_NAME,
+            emitToConsole: false,
+            level: loggerLike?.level === undefined ? undefined : coerceLogLevel(loggerLike.level)
+        });
+        const command = resolveRubyLspCommand(repositoryRootPath, runtimeLogger);
+        const handler = new NodeLanguageServerHandler({
+            cmd: command,
+            cwd: repositoryRootPath
+        }, {
+            requestTimeoutSeconds: options?.timeout ?? DEFAULT_REQUEST_TIMEOUT
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            timeout: options?.timeout ?? DEFAULT_REQUEST_TIMEOUT,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.handlerInstance = 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.handlerInstance.onRequest('client/registerCapability', noop);
+        this.handlerInstance.onRequest('workspace/executeClientCommand', () => []);
+        this.handlerInstance.onNotification('language/status', (payload) => {
+            const params = payload;
+            if (params?.type) {
+                this.logger.info(`ruby-lsp status: ${params.type}${params.message ? ` (${params.message})` : ''}`);
+            }
+        });
+        this.handlerInstance.onNotification('$/progress', (payload) => {
+            const info = payload && typeof payload === 'object' ? payload : null;
+            if (info && 'value' in info) {
+                this.logger.debug(`ruby-lsp progress: ${JSON.stringify(info)}`);
+            }
+        });
+        this.handlerInstance.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`ruby-lsp: ${message}`);
+            }
+        });
+        this.handlerInstance.onNotification('textDocument/publishDiagnostics', noop);
+    }
+    initializeLanguageServer() {
+        this.logger.info('ruby-lsp を初期化しています');
+        const params = this.buildInitializeParams();
+        const response = this.handlerInstance.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.handlerInstance.notify.initialized({});
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            processId: process.pid,
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            capabilities: buildClientCapabilities(),
+            initializationOptions: buildInitializationOptions(this.repositoryRootPath),
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities || typeof capabilities !== 'object') {
+            throw new Error('ruby-lsp 初期化レスポンスに capabilities が含まれていません。');
+        }
+        const textDocumentCaps = capabilities;
+        if (!Object.prototype.hasOwnProperty.call(textDocumentCaps, 'textDocumentSync')) {
+            throw new Error('ruby-lsp が textDocumentSync capability を報告しませんでした。');
+        }
+        if (!Object.prototype.hasOwnProperty.call(textDocumentCaps, 'completionProvider')) {
+            throw new Error('ruby-lsp が completionProvider capability を報告しませんでした。');
+        }
+    }
+}
+function resolveRubyLspCommand(repositoryRootPath, logger) {
+    const override = process.env[RUBY_LSP_PATH_ENV]?.trim();
+    if (override) {
+        logger.info(`SERENA_RUBY_LSP_PATH を使用: ${override}`);
+        return parseCommandOverride(override);
+    }
+    if (process.env[RUBY_LSP_ASSUME_ENV] === '1') {
+        logger.info('SERENA_ASSUME_RUBY_LSP=1 のためランタイム検証をスキップします');
+        const fallback = findCommand('ruby-lsp') ?? 'ruby-lsp';
+        return [fallback];
+    }
+    ensureRubyAvailable(logger, repositoryRootPath);
+    const gemfilePath = path.join(repositoryRootPath, 'Gemfile');
+    const gemfileLockPath = path.join(repositoryRootPath, 'Gemfile.lock');
+    const isBundlerProject = fs.existsSync(gemfilePath);
+    if (isBundlerProject) {
+        const bundleCommand = findBundleExecutable(repositoryRootPath);
+        if (!bundleCommand) {
+            logger.warn('Gemfile は見つかりましたが bundle コマンドが見つかりません。PATH または bin/bundle を確認してください。');
+        }
+        else if (gemfileLockContains(gemfileLockPath, 'ruby-lsp')) {
+            logger.info(`bundle exec ruby-lsp を使用します (${bundleCommand})`);
+            return [bundleCommand, 'exec', 'ruby-lsp'];
+        }
+        else {
+            logger.warn('Gemfile.lock に ruby-lsp が含まれていません。グローバルインストールを探します。');
+        }
+    }
+    const globalRubyLsp = findCommand('ruby-lsp');
+    if (globalRubyLsp) {
+        logger.info(`PATH から ruby-lsp を検出: ${globalRubyLsp}`);
+        return [globalRubyLsp];
+    }
+    installGem('ruby-lsp', logger, repositoryRootPath);
+    const installedRubyLsp = findCommand('ruby-lsp');
+    if (installedRubyLsp) {
+        logger.info(`gem install 後の ruby-lsp を検出: ${installedRubyLsp}`);
+        return [installedRubyLsp];
+    }
+    logger.warn('ruby-lsp のパス解決に失敗しました。最終手段として ruby-lsp を直接実行します。');
+    return ['ruby-lsp'];
+}
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+    }
+    return Array.from(merged);
+}
+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 {
+        workspace: {
+            workspaceEdit: { documentChanges: true },
+            configuration: true
+        },
+        window: {
+            workDoneProgress: true
+        },
+        textDocument: {
+            documentSymbol: {
+                hierarchicalDocumentSymbolSupport: true,
+                symbolKind: { valueSet: symbolKinds }
+            },
+            completion: {
+                completionItem: {
+                    snippetSupport: true,
+                    commitCharactersSupport: true
+                }
+            }
+        }
+    };
+}
+function buildInitializationOptions(repositoryRootPath) {
+    return {
+        experimentalFeaturesEnabled: false,
+        featuresConfiguration: {},
+        indexing: {
+            includedPatterns: ['**/*.rb', '**/*.rake', '**/*.ru', '**/*.erb'],
+            excludedPatterns: buildRubyExcludePatterns(repositoryRootPath)
+        }
+    };
+}
+function parseCommandOverride(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return ['ruby-lsp'];
+    }
+    const matches = trimmed.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+    if (!matches) {
+        return [trimmed];
+    }
+    return matches.map((segment) => segment.replace(/^['"]|['"]$/g, ''));
+}
+registerLanguageServer(Language.RUBY, RubyLspLanguageServer);

package/dist/solidlsp/language_servers/rust_analyzer.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 RustAnalyzerLanguageServer 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/rust_analyzer.js

@@ -0,0 +1,96 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import { Language } from '../ls_config.js';
+import { ensureDefaultSubprocessOptions } from '../util/subprocess_util.js';
+import { SolidLanguageServer, registerLanguageServer } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+function getRustupVersion() {
+    const result = spawnSync('rustup', ['--version'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status === 0 && result.stdout) {
+        return result.stdout.trim();
+    }
+    return null;
+}
+function getRustAnalyzerViaRustup() {
+    const result = spawnSync('rustup', ['which', 'rust-analyzer'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status === 0 && result.stdout) {
+        return result.stdout.trim();
+    }
+    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 && result.stdout) {
+        const firstLine = result.stdout.split(/\r?\n/)[0]?.trim();
+        return firstLine && firstLine.length > 0 ? firstLine : null;
+    }
+    return null;
+}
+function ensureRustAnalyzerBinary() {
+    const overridePath = process.env.SERENA_RUST_ANALYZER_PATH;
+    if (overridePath) {
+        return overridePath;
+    }
+    const fromRustup = getRustAnalyzerViaRustup();
+    if (fromRustup && fs.existsSync(fromRustup)) {
+        return fromRustup;
+    }
+    const fromPath = whichBinary('rust-analyzer');
+    if (fromPath) {
+        return fromPath;
+    }
+    const rustupVersion = getRustupVersion();
+    if (!rustupVersion) {
+        throw new Error('Neither rust-analyzer nor rustup is installed. Install Rust via https://rustup.rs/ or provide rust-analyzer in PATH.');
+    }
+    const installResult = spawnSync('rustup', ['component', 'add', 'rust-analyzer'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (installResult.status !== 0) {
+        throw new Error(`Failed to install rust-analyzer via rustup: ${installResult.stderr ?? installResult.stdout}`);
+    }
+    const installedPath = getRustAnalyzerViaRustup();
+    if (installedPath && fs.existsSync(installedPath)) {
+        return installedPath;
+    }
+    throw new Error('rust-analyzer installation succeeded but binary not found in PATH.');
+}
+function mergeIgnoredPaths(existing) {
+    const merged = new Set(existing ?? []);
+    merged.add('target');
+    return Array.from(merged);
+}
+export class RustAnalyzerLanguageServer extends SolidLanguageServer {
+    handler;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths)
+        };
+        const binaryPath = ensureRustAnalyzerBinary();
+        const handler = new NodeLanguageServerHandler({
+            cmd: binaryPath,
+            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(`rust-analyzer: ${payload.message ?? ''}`);
+            }
+        });
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+        this.handler.onNotification('experimental/serverStatus', noop);
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onRequest('workspace/executeClientCommand', () => []);
+    }
+}
+registerLanguageServer(Language.RUST, RustAnalyzerLanguageServer);

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

@@ -0,0 +1,18 @@
+import { type LogLevel } from '../../serena/util/logging.js';
+import { SolidLanguageServer, type LanguageServerConfigLike, type SolidLspSettingsInit } from '../ls.js';
+export declare class SolargraphLanguageServer extends SolidLanguageServer {
+    private readonly handlerInstance;
+    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;
+}

package/dist/solidlsp/language_servers/solargraph.js

@@ -0,0 +1,208 @@
+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 { SolidLanguageServer, registerLanguageServer, coerceLogLevel } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { buildRubyExcludePatterns, ensureRubyAvailable, findBundleExecutable, findCommand, gemfileLockContains, installGem } from './ruby_common.js';
+const SOLARGRAPH_ASSUME_ENV = 'SERENA_ASSUME_SOLARGRAPH';
+const SOLARGRAPH_PATH_ENV = 'SERENA_SOLARGRAPH_PATH';
+const SOLARGRAPH_LOGGER_NAME = 'solidlsp.language_servers.solargraph';
+const DEFAULT_TIMEOUT = 120; // seconds
+const SOLARGRAPH_IGNORED_DIRECTORIES = [
+    'vendor',
+    '.bundle',
+    'tmp',
+    'log',
+    'coverage',
+    '.yardoc',
+    'doc',
+    'node_modules',
+    'storage'
+];
+export class SolargraphLanguageServer extends SolidLanguageServer {
+    handlerInstance;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const adjustedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, SOLARGRAPH_IGNORED_DIRECTORIES)
+        };
+        const { logger: runtimeLogger } = createSerenaLogger({
+            name: SOLARGRAPH_LOGGER_NAME,
+            emitToConsole: false,
+            level: loggerLike?.level === undefined ? undefined : coerceLogLevel(loggerLike.level)
+        });
+        const command = resolveSolargraphCommand(repositoryRootPath, runtimeLogger);
+        const handler = new NodeLanguageServerHandler({
+            cmd: command,
+            cwd: repositoryRootPath
+        }, {
+            requestTimeoutSeconds: options?.timeout ?? DEFAULT_TIMEOUT
+        });
+        super(adjustedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            timeout: options?.timeout ?? DEFAULT_TIMEOUT,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.handlerInstance = 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.handlerInstance.onRequest('client/registerCapability', (params) => {
+            this.logger.debug(`solargraph registerCapability: ${JSON.stringify(params)}`);
+            return [];
+        });
+        this.handlerInstance.onRequest('workspace/executeClientCommand', () => []);
+        this.handlerInstance.onNotification('language/status', (payload) => {
+            const params = payload;
+            if (params?.type) {
+                this.logger.info(`solargraph status: ${params.type}${params.message ? ` (${params.message})` : ''}`);
+            }
+        });
+        this.handlerInstance.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`solargraph: ${message}`);
+            }
+        });
+        this.handlerInstance.onNotification('$/progress', noop);
+        this.handlerInstance.onNotification('textDocument/publishDiagnostics', noop);
+        this.handlerInstance.onNotification('language/actionableNotification', noop);
+    }
+    initializeLanguageServer() {
+        this.logger.info('Solargraph を初期化しています');
+        const params = this.buildInitializeParams();
+        const response = this.handlerInstance.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.handlerInstance.notify.initialized({});
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            processId: process.pid,
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            capabilities: buildClientCapabilities(),
+            initializationOptions: {
+                exclude: buildRubyExcludePatterns(this.repositoryRootPath)
+            },
+            trace: 'verbose',
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities || typeof capabilities !== 'object') {
+            throw new Error('Solargraph 初期化レスポンスに capabilities が含まれていません。');
+        }
+        const textDocumentCaps = capabilities;
+        if (!Object.prototype.hasOwnProperty.call(textDocumentCaps, 'textDocumentSync')) {
+            throw new Error('Solargraph が textDocumentSync capability を報告しませんでした。');
+        }
+        if (!Object.prototype.hasOwnProperty.call(textDocumentCaps, 'completionProvider')) {
+            throw new Error('Solargraph が completionProvider capability を報告しませんでした。');
+        }
+    }
+}
+function resolveSolargraphCommand(repositoryRootPath, logger) {
+    const override = process.env[SOLARGRAPH_PATH_ENV]?.trim();
+    if (override) {
+        logger.info(`SERENA_SOLARGRAPH_PATH を使用: ${override}`);
+        return parseCommandOverride(override, true);
+    }
+    if (process.env[SOLARGRAPH_ASSUME_ENV] === '1') {
+        logger.info('SERENA_ASSUME_SOLARGRAPH=1 によりランタイム検証をスキップします');
+        const fallback = findCommand('solargraph') ?? 'solargraph';
+        return [fallback, 'stdio'];
+    }
+    ensureRubyAvailable(logger, repositoryRootPath);
+    const gemfilePath = path.join(repositoryRootPath, 'Gemfile');
+    const gemfileLockPath = path.join(repositoryRootPath, 'Gemfile.lock');
+    const isBundlerProject = fs.existsSync(gemfilePath);
+    if (isBundlerProject) {
+        const bundleCommand = findBundleExecutable(repositoryRootPath);
+        if (!bundleCommand) {
+            throw new Error('Bundler プロジェクトですが bundle コマンドが見つかりません。Bundler をインストールし PATH を設定してください。');
+        }
+        if (!gemfileLockContains(gemfileLockPath, 'solargraph')) {
+            throw new Error("Gemfile.lock に solargraph が含まれていません。Gemfile に `gem 'solargraph'` を追加して `bundle install` を実行してください。");
+        }
+        logger.info(`bundle exec solargraph を使用します (${bundleCommand})`);
+        return [bundleCommand, 'exec', 'solargraph', 'stdio'];
+    }
+    const globalSolargraph = findCommand('solargraph');
+    if (globalSolargraph) {
+        logger.info(`PATH から solargraph を検出: ${globalSolargraph}`);
+        return [globalSolargraph, 'stdio'];
+    }
+    installGem('solargraph', logger, repositoryRootPath);
+    const installedSolargraph = findCommand('solargraph');
+    if (installedSolargraph) {
+        logger.info(`gem install 後の solargraph を検出: ${installedSolargraph}`);
+        return [installedSolargraph, 'stdio'];
+    }
+    logger.warn('solargraph のパス解決に失敗しました。最終手段として solargraph stdio を使用します。');
+    return ['solargraph', 'stdio'];
+}
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+    }
+    return Array.from(merged);
+}
+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 {
+        workspace: {
+            workspaceEdit: { documentChanges: true }
+        },
+        textDocument: {
+            documentSymbol: {
+                hierarchicalDocumentSymbolSupport: true,
+                symbolKind: { valueSet: symbolKinds }
+            }
+        }
+    };
+}
+function parseCommandOverride(value, appendStdio) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return appendStdio ? ['solargraph', 'stdio'] : ['solargraph'];
+    }
+    const matches = trimmed.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+    const parts = matches ? matches.map((segment) => segment.replace(/^['"]|['"]$/g, '')) : [trimmed];
+    if (appendStdio && parts[parts.length - 1] !== 'stdio') {
+        parts.push('stdio');
+    }
+    return parts;
+}
+registerLanguageServer(Language.RUBY_SOLARGRAPH, SolargraphLanguageServer);

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

@@ -0,0 +1,24 @@
+import type { LogLevel } from '../../serena/util/logging.js';
+import { SolidLanguageServer, type LanguageServerConfigLike, type ReferenceInSymbol, type ReferencingSymbolsOptions, type SolidLspSettingsInit } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+export declare class SourceKitLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    private readonly versionDescription;
+    private initialized;
+    private firstReferenceDelayApplied;
+    private initializationTimestamp;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: number | LogLevel;
+    } | null, repositoryRootPath: string, options?: {
+        timeout?: number | null;
+        solidlspSettings?: SolidLspSettingsInit;
+    });
+    start(): this;
+    stop(shutdownTimeout?: number): void;
+    requestReferencingSymbols(options: ReferencingSymbolsOptions): ReferenceInSymbol[];
+    private registerHandlers;
+    private initializeLanguageServer;
+    private buildInitializeParams;
+    private applyInitialReferenceDelay;
+    private computeInitialReferenceDelayMs;
+}