@nogataka/smart-edit 0.0.14

package/dist/serena/util/shell.js

@@ -0,0 +1,95 @@
+import { execFile, spawn } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { ensureDefaultSubprocessOptions } from '../../solidlsp/util/subprocess_util.js';
+export async function executeShellCommand(command, { cwd, captureStderr = false, env } = {}) {
+    const resolvedCwd = cwd ? path.resolve(cwd) : process.cwd();
+    const mergedEnv = env ? { ...process.env, ...env } : process.env;
+    return new Promise((resolve, reject) => {
+        const spawnOptions = ensureDefaultSubprocessOptions({
+            shell: true,
+            cwd: resolvedCwd,
+            env: mergedEnv,
+            stdio: ['ignore', 'pipe', captureStderr ? 'pipe' : 'inherit']
+        });
+        const child = spawn(command, spawnOptions);
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout) {
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                stdout += chunk;
+            });
+        }
+        if (captureStderr && child.stderr) {
+            child.stderr.setEncoding('utf8');
+            child.stderr.on('data', (chunk) => {
+                stderr += chunk;
+            });
+        }
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            const returnCode = typeof code === 'number'
+                ? code
+                : resolveSignalExitCode(signal);
+            resolve({
+                stdout,
+                stderr: captureStderr ? stderr : undefined,
+                returnCode,
+                cwd: resolvedCwd,
+                signal: signal ?? undefined
+            });
+        });
+    });
+}
+export async function subprocessCheckOutput(args, { encoding = 'utf8', strip = true, timeoutMs, cwd, env } = {}) {
+    if (args.length === 0) {
+        throw new Error('subprocessCheckOutput requires at least one argument');
+    }
+    const [command, ...commandArgs] = args;
+    const resolvedCwd = cwd ? path.resolve(cwd) : undefined;
+    /*
+     * encoding option is validated by the SubprocessCheckOutputOptions schema above. The Node.js type
+     * signatures expose these helper utilities with loose `any` assignments, so we locally suppress
+     * the unsafe-assignment diagnostics while building the exec options object.
+     */
+    const execOptions = ensureDefaultSubprocessOptions({
+        encoding
+    });
+    if (resolvedCwd) {
+        execOptions.cwd = resolvedCwd;
+    }
+    if (env) {
+        execOptions.env = { ...process.env, ...env };
+    }
+    if (typeof timeoutMs === 'number') {
+        execOptions.timeout = timeoutMs;
+    }
+    const { stdout } = await execFilePromise(command, commandArgs, execOptions);
+    return strip ? stdout.trim() : stdout;
+}
+function resolveSignalExitCode(signal) {
+    if (!signal) {
+        return 0;
+    }
+    const signalNumber = os.constants.signals[signal];
+    if (typeof signalNumber === 'number') {
+        return -signalNumber;
+    }
+    return 0;
+}
+function execFilePromise(command, args, options) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, options, (error, stdout, stderr) => {
+            if (error) {
+                const wrappedError = error instanceof Error
+                    ? error
+                    : new Error('Subprocess execution failed');
+                reject(wrappedError);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}

package/dist/serena/util/thread.d.ts

@@ -0,0 +1,23 @@
+export declare class TimeoutException extends Error {
+    readonly timeoutSeconds: number;
+    constructor(message: string, timeoutSeconds: number);
+}
+export declare enum ExecutionStatus {
+    Success = "success",
+    Timeout = "timeout",
+    Exception = "error"
+}
+export declare class ExecutionResult<T> {
+    resultValue: T | undefined;
+    status: ExecutionStatus | undefined;
+    exception: Error | undefined;
+    setResultValue(value: T): void;
+    setTimedOut(exception: TimeoutException): void;
+    setException(exception: Error): void;
+    toString(): string;
+}
+export interface ExecuteWithTimeoutOptions {
+    timeoutSeconds: number;
+    functionName: string;
+}
+export declare function executeWithTimeout<T>(func: () => T | Promise<T>, { timeoutSeconds, functionName }: ExecuteWithTimeoutOptions): Promise<ExecutionResult<T>>;

package/dist/serena/util/thread.js

@@ -0,0 +1,88 @@
+export class TimeoutException extends Error {
+    timeoutSeconds;
+    constructor(message, timeoutSeconds) {
+        super(message);
+        this.name = 'TimeoutException';
+        this.timeoutSeconds = timeoutSeconds;
+    }
+}
+export var ExecutionStatus;
+(function (ExecutionStatus) {
+    ExecutionStatus["Success"] = "success";
+    ExecutionStatus["Timeout"] = "timeout";
+    ExecutionStatus["Exception"] = "error";
+})(ExecutionStatus || (ExecutionStatus = {}));
+export class ExecutionResult {
+    resultValue;
+    status;
+    exception;
+    setResultValue(value) {
+        this.resultValue = value;
+        this.status = ExecutionStatus.Success;
+    }
+    setTimedOut(exception) {
+        this.exception = exception;
+        this.status = ExecutionStatus.Timeout;
+    }
+    setException(exception) {
+        this.exception = exception;
+        this.status = ExecutionStatus.Exception;
+    }
+    toString() {
+        const parts = [
+            `status=${this.status ?? 'unknown'}`,
+            `result=${this.resultValue !== undefined ? 'set' : 'unset'}`,
+            `exception=${this.exception ? this.exception.message : 'none'}`
+        ];
+        return `ExecutionResult(${parts.join(', ')})`;
+    }
+}
+export async function executeWithTimeout(func, { timeoutSeconds, functionName }) {
+    const executionResult = new ExecutionResult();
+    const timeout = Math.max(0, timeoutSeconds);
+    const timeoutException = new TimeoutException(`Execution of '${functionName}' timed out after ${timeout} seconds.`, timeout);
+    let timeoutHandle;
+    let didTimeout = false;
+    const timeoutPromise = (async () => {
+        await new Promise((resolve) => {
+            timeoutHandle = setNodeTimeout(resolve, timeout * 1000);
+            timeoutHandle.unref?.();
+        });
+        didTimeout = true;
+        throw timeoutException;
+    })();
+    let operationPromise;
+    try {
+        operationPromise = Promise.resolve(func());
+    }
+    catch (error) {
+        operationPromise = Promise.reject(normalizeToError(error));
+    }
+    try {
+        const value = await Promise.race([operationPromise, timeoutPromise]);
+        if (!didTimeout) {
+            executionResult.setResultValue(value);
+        }
+    }
+    catch (error) {
+        if (error === timeoutException) {
+            executionResult.setTimedOut(timeoutException);
+        }
+        else {
+            executionResult.setException(normalizeToError(error));
+        }
+    }
+    finally {
+        if (timeoutHandle) {
+            clearNodeTimeout(timeoutHandle);
+        }
+    }
+    return executionResult;
+}
+function normalizeToError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    return new Error(String(value));
+}
+import { clearTimeout as clearNodeTimeout, setTimeout as setNodeTimeout } from 'node:timers';

package/dist/serena/version.d.ts

@@ -0,0 +1 @@
+export declare function serenaVersion(): string;

package/dist/serena/version.js

@@ -0,0 +1,23 @@
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { createSerenaLogger } from './util/logging.js';
+const require = createRequire(import.meta.url);
+const { version: packageVersion } = require('../../package.json');
+const { logger } = createSerenaLogger({ name: 'serena.version', emitToConsole: false, level: 'info' });
+export function serenaVersion() {
+    let version = packageVersion ?? '0.0.0';
+    try {
+        const commit = execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf-8' }).trim();
+        if (commit.length > 0) {
+            version += `-${commit.slice(0, 8)}`;
+        }
+        const status = execFileSync('git', ['status', '--porcelain'], { encoding: 'utf-8' }).trim();
+        if (status.length > 0) {
+            version += '-dirty';
+        }
+    }
+    catch (error) {
+        logger.debug('Failed to read git metadata for version string', error);
+    }
+    return version;
+}

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

@@ -0,0 +1,23 @@
+import './bash_language_server.js';
+import './csharp_language_server.js';
+import './clangd_language_server.js';
+import './clojure_lsp.js';
+import './eclipse_jdtls.js';
+import './erlang_language_server.js';
+import './intelephense.js';
+import './kotlin_language_server.js';
+import './dart_language_server.js';
+import './gopls.js';
+import './terraform_ls.js';
+import './pyright_server.js';
+import './jedi_server.js';
+import './rust_analyzer.js';
+import './typescript_language_server.js';
+import './vts_language_server.js';
+import './lua_ls.js';
+import './r_language_server.js';
+import './ruby_lsp.js';
+import './solargraph.js';
+import './sourcekit_lsp.js';
+import './nixd_language_server.js';
+import './zls.js';

package/dist/solidlsp/language_servers/autoload.js

@@ -0,0 +1,25 @@
+// Autoload registry for SolidLSP language servers implemented in TypeScript.
+// Import modules here to ensure they register themselves at runtime.
+import './bash_language_server.js';
+import './csharp_language_server.js';
+import './clangd_language_server.js';
+import './clojure_lsp.js';
+import './eclipse_jdtls.js';
+import './erlang_language_server.js';
+import './intelephense.js';
+import './kotlin_language_server.js';
+import './dart_language_server.js';
+import './gopls.js';
+import './terraform_ls.js';
+import './pyright_server.js';
+import './jedi_server.js';
+import './rust_analyzer.js';
+import './typescript_language_server.js';
+import './vts_language_server.js';
+import './lua_ls.js';
+import './r_language_server.js';
+import './ruby_lsp.js';
+import './solargraph.js';
+import './sourcekit_lsp.js';
+import './nixd_language_server.js';
+import './zls.js';

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

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

package/dist/solidlsp/language_servers/bash_language_server.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createSerenaLogger } from '../../serena/util/logging.js';
+import { Language } from '../ls_config.js';
+import { SolidLanguageServer, SolidLspSettings, registerLanguageServer } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { Platform, RuntimeDependencyCollection, quoteWindowsPath } from './common.js';
+function resolveRuntimeDirectory(settings) {
+    return path.join(settings.languageServersStaticDir, 'BashLanguageServer');
+}
+function ensureDependencies(settings) {
+    const runtimeDir = resolveRuntimeDirectory(settings);
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        return runtimeDir;
+    }
+    const dependencies = new RuntimeDependencyCollection([
+        {
+            id: 'bash-language-server',
+            description: 'bash-language-server npm package',
+            command: ['npm', 'install', '--prefix', './', 'bash-language-server@5.6.0'],
+            platformId: 'any'
+        }
+    ]);
+    const { logger } = createSerenaLogger({
+        emitToConsole: false,
+        name: 'solidlsp.language_servers.bash'
+    });
+    try {
+        dependencies.install(logger, runtimeDir);
+    }
+    catch (error) {
+        logger.warn(`npm install for bash-language-server failed (${String(error)}). Falling back to system binary if available.`);
+    }
+    return runtimeDir;
+}
+function determineCommand(settings) {
+    const runtimeDir = ensureDependencies(settings);
+    const binName = Platform.isWindows() ? 'bash-language-server.cmd' : 'bash-language-server';
+    const localBinary = path.join(runtimeDir, 'node_modules', '.bin', binName);
+    if (fs.existsSync(localBinary)) {
+        return {
+            cmd: `${quoteWindowsPath(localBinary)} start`
+        };
+    }
+    return {
+        cmd: 'bash-language-server start'
+    };
+}
+export class BashLanguageServer extends SolidLanguageServer {
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const launchInfo = determineCommand(solidSettings);
+        const handler = new NodeLanguageServerHandler({
+            ...launchInfo,
+            cwd: repositoryRootPath
+        });
+        super(config, loggerLike, repositoryRootPath, {
+            ...options,
+            solidlspSettings: options?.solidlspSettings,
+            handler
+        });
+    }
+}
+registerLanguageServer(Language.BASH, BashLanguageServer);

package/dist/solidlsp/language_servers/clangd_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 ClangdLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: number | LogLevel;
+    } | null, repositoryRootPath: string, options?: {
+        timeout?: number | null;
+        solidlspSettings?: SolidLspSettingsInit;
+    });
+    private registerDefaultHandlers;
+}

package/dist/solidlsp/language_servers/clangd_language_server.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createSerenaLogger } from '../../serena/util/logging.js';
+import { Language } from '../ls_config.js';
+import { SolidLanguageServer, SolidLspSettings, registerLanguageServer, coerceLogLevel } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+import { RuntimeDependencyCollection, quoteWindowsPath } from './common.js';
+const CLANGD_DEPENDENCIES = [
+    {
+        id: 'clangd',
+        description: 'Clangd for Linux (x64)',
+        url: 'https://github.com/clangd/clangd/releases/download/19.1.2/clangd-linux-19.1.2.zip',
+        platformId: 'linux-x64',
+        archiveType: 'zip',
+        binaryName: 'clangd_19.1.2/bin/clangd'
+    },
+    {
+        id: 'clangd',
+        description: 'Clangd for Windows (x64)',
+        url: 'https://github.com/clangd/clangd/releases/download/19.1.2/clangd-windows-19.1.2.zip',
+        platformId: 'win-x64',
+        archiveType: 'zip',
+        binaryName: 'clangd_19.1.2/bin/clangd.exe'
+    },
+    {
+        id: 'clangd',
+        description: 'Clangd for macOS (x64)',
+        url: 'https://github.com/clangd/clangd/releases/download/19.1.2/clangd-mac-19.1.2.zip',
+        platformId: 'osx-x64',
+        archiveType: 'zip',
+        binaryName: 'clangd_19.1.2/bin/clangd'
+    },
+    {
+        id: 'clangd',
+        description: 'Clangd for macOS (arm64)',
+        url: 'https://github.com/clangd/clangd/releases/download/19.1.2/clangd-mac-19.1.2.zip',
+        platformId: 'osx-arm64',
+        archiveType: 'zip',
+        binaryName: 'clangd_19.1.2/bin/clangd'
+    }
+];
+function resolveRuntimeDirectory(settings) {
+    const dir = path.join(settings.languageServersStaticDir, 'clangd');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function ensureClangdBinary(runtimeDir, dependencies, loggerLevel) {
+    const { logger } = createSerenaLogger({
+        name: 'solidlsp.language_servers.clangd',
+        emitToConsole: false,
+        level: loggerLevel === undefined ? undefined : coerceLogLevel(loggerLevel)
+    });
+    const binaryPath = dependencies.binaryPath(runtimeDir);
+    if (!fs.existsSync(binaryPath)) {
+        if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+            throw new Error(`clangd executable not found at ${binaryPath}. Set SERENA_SKIP_RUNTIME_INSTALL=0 to allow downloads.`);
+        }
+        const dep = dependencies.getSingleDepForCurrentPlatform();
+        logger.info(`Downloading clangd runtime dependency from ${dep.url}`);
+        dependencies.install(logger, runtimeDir);
+        if (!fs.existsSync(binaryPath)) {
+            throw new Error(`clangd executable not found after installation (expected at ${binaryPath}). Please install clangd manually from https://clangd.llvm.org/installation.`);
+        }
+    }
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(binaryPath, 0o755);
+        }
+        catch {
+            // ignore chmod failures
+        }
+    }
+    return binaryPath;
+}
+export class ClangdLanguageServer extends SolidLanguageServer {
+    handler;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const runtimeDir = resolveRuntimeDirectory(solidSettings);
+        const dependencies = new RuntimeDependencyCollection(CLANGD_DEPENDENCIES);
+        const binaryPath = ensureClangdBinary(runtimeDir, dependencies, loggerLike?.level);
+        const handler = new NodeLanguageServerHandler({
+            cmd: quoteWindowsPath(binaryPath),
+            cwd: repositoryRootPath
+        });
+        super(config, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.handler = handler;
+        this.registerDefaultHandlers();
+    }
+    registerDefaultHandlers() {
+        const noop = () => undefined;
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+        this.handler.onNotification('language/actionableNotification', noop);
+        this.handler.onNotification('experimental/serverStatus', noop);
+        this.handler.onNotification('window/logMessage', (payload) => {
+            const message = typeof payload === 'object' && payload !== null ? payload.message : null;
+            if (typeof message === 'string' && message.trim().length > 0) {
+                this.logger.info(`clangd: ${message}`);
+            }
+        });
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onRequest('workspace/executeClientCommand', () => []);
+    }
+}
+registerLanguageServer(Language.CPP, ClangdLanguageServer);

package/dist/solidlsp/language_servers/clojure_lsp.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 ClojureLanguageServer 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/clojure_lsp.js

@@ -0,0 +1,137 @@
+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 CLOJURE_LSP_RELEASES = 'https://github.com/clojure-lsp/clojure-lsp/releases/latest/download';
+const CLOJURE_DEPENDENCIES = [
+    {
+        id: 'clojure-lsp',
+        url: `${CLOJURE_LSP_RELEASES}/clojure-lsp-native-macos-aarch64.zip`,
+        platformId: 'osx-arm64',
+        archiveType: 'zip',
+        binaryName: 'clojure-lsp'
+    },
+    {
+        id: 'clojure-lsp',
+        url: `${CLOJURE_LSP_RELEASES}/clojure-lsp-native-macos-amd64.zip`,
+        platformId: 'osx-x64',
+        archiveType: 'zip',
+        binaryName: 'clojure-lsp'
+    },
+    {
+        id: 'clojure-lsp',
+        url: `${CLOJURE_LSP_RELEASES}/clojure-lsp-native-linux-aarch64.zip`,
+        platformId: 'linux-arm64',
+        archiveType: 'zip',
+        binaryName: 'clojure-lsp'
+    },
+    {
+        id: 'clojure-lsp',
+        url: `${CLOJURE_LSP_RELEASES}/clojure-lsp-native-linux-amd64.zip`,
+        platformId: 'linux-x64',
+        archiveType: 'zip',
+        binaryName: 'clojure-lsp'
+    },
+    {
+        id: 'clojure-lsp',
+        url: `${CLOJURE_LSP_RELEASES}/clojure-lsp-native-windows-amd64.zip`,
+        platformId: 'win-x64',
+        archiveType: 'zip',
+        binaryName: 'clojure-lsp.exe'
+    }
+];
+function verifyClojureCli() {
+    if (process.env.SERENA_ASSUME_CLOJURE === '1') {
+        return;
+    }
+    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+    const clojureExists = spawnSync(whichCmd, ['clojure'], ensureDefaultSubprocessOptions({ stdio: 'ignore' })).status === 0;
+    if (!clojureExists) {
+        throw new Error('`clojure` CLI was not found in PATH. Please install the official Clojure CLI from https://clojure.org/guides/getting_started');
+    }
+    const helpResult = spawnSync('clojure', ['--help'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (helpResult.status !== 0 || !helpResult.stdout.includes('-Aaliases')) {
+        throw new Error('Detected a `clojure` executable, but it does not appear to be the official CLI (missing -Aaliases support).');
+    }
+    const spathResult = spawnSync('clojure', ['-Spath'], ensureDefaultSubprocessOptions({}));
+    if (spathResult.status !== 0) {
+        throw new Error('`clojure -Spath` failed; ensure you are using Clojure CLI 1.10 or newer.');
+    }
+}
+function resolveRuntimeDirectory(settings) {
+    const dir = path.join(settings.languageServersStaticDir, 'clojure-lsp');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function ensureBinary(runtimeDir, dependencies, loggerLevel) {
+    const { logger } = createSerenaLogger({
+        name: 'solidlsp.language_servers.clojure',
+        emitToConsole: false,
+        level: loggerLevel === undefined ? undefined : coerceLogLevel(loggerLevel)
+    });
+    const binaryPath = dependencies.binaryPath(runtimeDir);
+    if (!fs.existsSync(binaryPath)) {
+        if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+            throw new Error(`clojure-lsp binary not found at ${binaryPath}. Allow downloads or install clojure-lsp manually.`);
+        }
+        logger.info('Downloading clojure-lsp runtime dependency.');
+        dependencies.install(logger, runtimeDir);
+        if (!fs.existsSync(binaryPath)) {
+            throw new Error(`Failed to install clojure-lsp runtime dependency (expected binary at ${binaryPath}).`);
+        }
+    }
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(binaryPath, 0o755);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return binaryPath;
+}
+export class ClojureLanguageServer extends SolidLanguageServer {
+    handler;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        verifyClojureCli();
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const runtimeDir = resolveRuntimeDirectory(solidSettings);
+        const dependencies = new RuntimeDependencyCollection(CLOJURE_DEPENDENCIES);
+        const binaryPath = ensureBinary(runtimeDir, dependencies, loggerLike?.level);
+        const handler = new NodeLanguageServerHandler({
+            cmd: quoteWindowsPath(binaryPath),
+            cwd: repositoryRootPath
+        });
+        super(config, 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(`clojure-lsp: ${payload.message ?? ''}`);
+            }
+        });
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+        this.handler.onNotification('language/actionableNotification', noop);
+        this.handler.onNotification('experimental/serverStatus', (payload) => {
+            if (payload && typeof payload === 'object' && payload.quiescent) {
+                this.logger.debug('clojure-lsp reported quiescent=true');
+            }
+        });
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onRequest('workspace/executeClientCommand', () => []);
+    }
+}
+registerLanguageServer(Language.CLOJURE, ClojureLanguageServer);