@nogataka/smart-edit 0.0.14

package/dist/solidlsp/language_servers/lua_ls.js

@@ -0,0 +1,319 @@
+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, quoteWindowsPath } from './common.js';
+const LUA_LS_VERSION = '3.15.0';
+const LUA_LS_DEPENDENCIES = [
+    {
+        id: 'lua-language-server',
+        platformId: 'linux-x64',
+        url: `https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-linux-x64.tar.gz`,
+        archiveType: 'tar',
+        binaryName: `lua-language-server-${LUA_LS_VERSION}-linux-x64/bin/lua-language-server`
+    },
+    {
+        id: 'lua-language-server',
+        platformId: 'linux-arm64',
+        url: `https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-linux-arm64.tar.gz`,
+        archiveType: 'tar',
+        binaryName: `lua-language-server-${LUA_LS_VERSION}-linux-arm64/bin/lua-language-server`
+    },
+    {
+        id: 'lua-language-server',
+        platformId: 'osx-x64',
+        url: `https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-darwin-x64.tar.gz`,
+        archiveType: 'tar',
+        binaryName: `lua-language-server-${LUA_LS_VERSION}-darwin-x64/bin/lua-language-server`
+    },
+    {
+        id: 'lua-language-server',
+        platformId: 'osx-arm64',
+        url: `https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-darwin-arm64.tar.gz`,
+        archiveType: 'tar',
+        binaryName: `lua-language-server-${LUA_LS_VERSION}-darwin-arm64/bin/lua-language-server`
+    },
+    {
+        id: 'lua-language-server',
+        platformId: 'win-x64',
+        url: `https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-win32-x64.zip`,
+        archiveType: 'zip',
+        binaryName: `lua-language-server-${LUA_LS_VERSION}-win32-x64/bin/lua-language-server.exe`
+    }
+];
+const LUA_IGNORED_DIRECTORIES = ['.luarocks', 'lua_modules', 'node_modules', 'build', 'dist', '.cache'];
+export class LuaLanguageServer extends SolidLanguageServer {
+    handlerInstance;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, LUA_IGNORED_DIRECTORIES)
+        };
+        const solidSettings = new SolidLspSettings(options?.solidlspSettings);
+        const runtimeDir = resolveRuntimeDirectory(solidSettings);
+        const dependencies = new RuntimeDependencyCollection(LUA_LS_DEPENDENCIES);
+        const binaryPath = ensureLuaLanguageServerBinary(runtimeDir, dependencies, loggerLike?.level);
+        const handler = new NodeLanguageServerHandler({
+            cmd: quoteWindowsPath(binaryPath),
+            cwd: repositoryRootPath
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            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.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`lua-language-server: ${message}`);
+            }
+        });
+        this.handlerInstance.onNotification('$/progress', noop);
+        this.handlerInstance.onNotification('textDocument/publishDiagnostics', noop);
+    }
+    initializeLanguageServer() {
+        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,
+            locale: 'en',
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            capabilities: buildClientCapabilities(),
+            initializationOptions: buildInitializationOptions(),
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('Lua language server initialize response is missing capabilities.');
+        }
+        const textDocumentCaps = capabilities;
+        if (!('textDocumentSync' in textDocumentCaps)) {
+            throw new Error('Lua language server did not advertise textDocumentSync capability.');
+        }
+        if (!('definitionProvider' in textDocumentCaps)) {
+            throw new Error('Lua language server did not advertise definitionProvider capability.');
+        }
+        if (!('documentSymbolProvider' in textDocumentCaps)) {
+            throw new Error('Lua language server did not advertise documentSymbolProvider capability.');
+        }
+        if (!('referencesProvider' in textDocumentCaps)) {
+            throw new Error('Lua language server did not advertise referencesProvider capability.');
+        }
+    }
+}
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+    }
+    return Array.from(merged);
+}
+function resolveRuntimeDirectory(settings) {
+    const runtimeDir = path.join(settings.languageServersStaticDir, 'lua-language-server');
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    return runtimeDir;
+}
+function ensureLuaLanguageServerBinary(runtimeDir, dependencies, loggerLevel) {
+    const overridePath = process.env.SERENA_LUA_LS_PATH;
+    if (overridePath && fs.existsSync(overridePath)) {
+        return overridePath;
+    }
+    const fromPath = whichBinary(process.platform === 'win32' ? 'lua-language-server.exe' : 'lua-language-server');
+    if (fromPath && fs.existsSync(fromPath)) {
+        return fromPath;
+    }
+    const known = locateInKnownLocations(runtimeDir);
+    if (known) {
+        return known;
+    }
+    const maybeInstalled = locateInstalledBinary(runtimeDir, dependencies);
+    if (maybeInstalled) {
+        return maybeInstalled;
+    }
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        throw new Error('lua-language-server binary not found. Allow downloads by unsetting SERENA_SKIP_RUNTIME_INSTALL or set SERENA_LUA_LS_PATH.');
+    }
+    const { logger } = createSerenaLogger({
+        name: 'solidlsp.language_servers.lua',
+        emitToConsole: false,
+        level: loggerLevel === undefined ? undefined : coerceLogLevel(loggerLevel)
+    });
+    logger.info('Downloading lua-language-server runtime dependency.');
+    dependencies.install(logger, runtimeDir);
+    const installed = locateInstalledBinary(runtimeDir, dependencies);
+    if (!installed) {
+        throw new Error('Failed to locate lua-language-server binary after installation.');
+    }
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(installed, 0o755);
+        }
+        catch {
+            // ignore chmod failures
+        }
+    }
+    return installed;
+}
+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/).map((line) => line.trim()).filter(Boolean);
+        return firstLine ?? null;
+    }
+    return null;
+}
+function locateInKnownLocations(runtimeDir) {
+    const home = os.homedir();
+    const executableName = process.platform === 'win32' ? 'lua-language-server.exe' : 'lua-language-server';
+    const candidates = [
+        path.join(runtimeDir, executableName),
+        path.join(runtimeDir, 'bin', executableName),
+        path.join(home, '.local', 'bin', executableName),
+        path.join(home, '.smart-edit', 'language_servers', 'lua', 'bin', executableName),
+        path.join('/usr/local/bin', executableName),
+        path.join('/opt/lua-language-server', 'bin', executableName)
+    ];
+    if (process.platform === 'win32') {
+        candidates.push(path.join(home, 'AppData', 'Local', 'lua-language-server', 'bin', 'lua-language-server.exe'), path.join(home, '.smart-edit', 'language_servers', 'lua', 'bin', 'lua-language-server.exe'));
+    }
+    for (const candidate of candidates) {
+        if (candidate && fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function locateInstalledBinary(runtimeDir, dependencies) {
+    const dep = dependencies.getSingleDepForCurrentPlatform();
+    const executableName = process.platform === 'win32' ? 'lua-language-server.exe' : 'lua-language-server';
+    const candidates = new Set();
+    if (dep.binaryName) {
+        candidates.add(path.join(runtimeDir, dep.binaryName));
+    }
+    candidates.add(path.join(runtimeDir, 'lua-language-server', 'bin', executableName));
+    candidates.add(path.join(runtimeDir, 'bin', executableName));
+    candidates.add(path.join(runtimeDir, executableName));
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function extractWindowMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const maybeMessage = payload.message;
+    return typeof maybeMessage === 'string' ? maybeMessage : 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']
+            },
+            signatureHelp: {
+                dynamicRegistration: true,
+                signatureInformation: {
+                    documentationFormat: ['markdown', 'plaintext'],
+                    parameterInformation: { labelOffsetSupport: true }
+                }
+            }
+        },
+        workspace: {
+            workspaceFolders: true,
+            didChangeConfiguration: { dynamicRegistration: true },
+            configuration: true,
+            symbol: {
+                dynamicRegistration: true,
+                symbolKind: { valueSet: symbolKinds }
+            }
+        }
+    };
+}
+function buildInitializationOptions() {
+    return {
+        runtime: {
+            version: 'Lua 5.4',
+            path: ['?.lua', '?/init.lua']
+        },
+        diagnostics: {
+            enable: true,
+            globals: ['vim', 'describe', 'it', 'before_each', 'after_each']
+        },
+        workspace: {
+            library: [],
+            checkThirdParty: false,
+            userThirdParty: []
+        },
+        telemetry: {
+            enable: false
+        },
+        completion: {
+            enable: true,
+            callSnippet: 'Both',
+            keywordSnippet: 'Both'
+        }
+    };
+}
+registerLanguageServer(Language.LUA, LuaLanguageServer);

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

@@ -0,0 +1,17 @@
+import type { LogLevel } from '../../serena/util/logging.js';
+import { type DocumentSymbolResult, type DocumentSymbolsOptions, type LanguageServerConfigLike, type SolidLanguageServerOptions, type UnifiedSymbolInformation, SolidLanguageServer } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+export declare class NixLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    private initialized;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: number | LogLevel;
+    } | null, repositoryRootPath: string, options?: SolidLanguageServerOptions);
+    start(): this;
+    stop(shutdownTimeout?: number): void;
+    requestDocumentSymbols(relativePath: string, options?: DocumentSymbolsOptions): DocumentSymbolResult;
+    private registerHandlers;
+    private initializeLanguageServer;
+    private verifyCapabilities;
+}
+export declare function extendNixSymbolTree(symbol: UnifiedSymbolInformation, fileContents: string): UnifiedSymbolInformation;

package/dist/solidlsp/language_servers/nixd_language_server.js

@@ -0,0 +1,341 @@
+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 { ensureDefaultSubprocessOptions } from '../util/subprocess_util.js';
+import { Language } from '../ls_config.js';
+import { SolidLanguageServer, registerLanguageServer } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+const NIXD_ASSUME_ENV = 'SERENA_ASSUME_NIXD';
+const NIXD_PATH_ENV = 'SERENA_NIXD_PATH';
+const NIX_IGNORED_PATTERNS = [
+    '**/result',
+    '**/result/**',
+    '**/result-*',
+    '**/result-*/**',
+    '**/.direnv',
+    '**/.direnv/**'
+];
+export class NixLanguageServer extends SolidLanguageServer {
+    handler;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPatterns(config.ignoredPaths, NIX_IGNORED_PATTERNS)
+        };
+        const binaryPath = ensureNixdRuntime();
+        const providedHandler = options.handler;
+        if (providedHandler && !(providedHandler instanceof NodeLanguageServerHandler)) {
+            throw new TypeError('NixLanguageServer requires a NodeLanguageServerHandler when supplying a custom handler.');
+        }
+        const handler = providedHandler ?? new NodeLanguageServerHandler({
+            cmd: 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;
+    }
+    requestDocumentSymbols(relativePath, options = {}) {
+        const result = super.requestDocumentSymbols(relativePath, options);
+        let fileContents;
+        try {
+            fileContents = this.retrieveFullFileContent(relativePath);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to read file contents for ${relativePath}: ${error.message}`);
+            return result;
+        }
+        return {
+            documentSymbols: result.documentSymbols.map((symbol) => extendNixSymbolTree(symbol, fileContents)),
+            outlineSymbols: result.outlineSymbols.map((symbol) => extendNixSymbolTree(symbol, fileContents))
+        };
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+        this.handler.onNotification('experimental/serverStatus', noop);
+        this.handler.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`nixd: ${message}`);
+            }
+        });
+    }
+    initializeLanguageServer() {
+        this.logger.info('Initializing nixd language server');
+        const params = buildInitializeParams(this.repositoryRootPath);
+        const response = this.handler.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.handler.notify.initialized({});
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities || typeof capabilities !== 'object') {
+            throw new Error('nixd initialization response is missing capabilities.');
+        }
+        const required = capabilities;
+        for (const key of ['textDocumentSync', 'definitionProvider', 'documentSymbolProvider', 'referencesProvider']) {
+            if (!(key in required)) {
+                throw new Error(`nixd did not advertise required capability '${key}'.`);
+            }
+        }
+    }
+}
+registerLanguageServer(Language.NIX, NixLanguageServer);
+function mergeIgnoredPatterns(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const pattern of additions) {
+        merged.add(pattern);
+    }
+    return Array.from(merged);
+}
+export function extendNixSymbolTree(symbol, fileContents) {
+    const extended = extendSymbolRange(symbol, fileContents);
+    const children = Array.isArray(symbol.children) ? symbol.children : undefined;
+    return {
+        ...extended,
+        children: children?.map((child) => extendNixSymbolTree(child, fileContents))
+    };
+}
+function extendSymbolRange(symbol, fileContents) {
+    const rangeHolder = symbol;
+    const { range } = rangeHolder;
+    const endPosition = range?.end ?? null;
+    if (!endPosition) {
+        return { ...symbol };
+    }
+    const endChar = endPosition.character;
+    if (endChar == null) {
+        return { ...symbol };
+    }
+    const endLine = endPosition.line;
+    if (typeof endLine !== 'number' || typeof endChar !== 'number') {
+        return { ...symbol };
+    }
+    const lines = fileContents.split('\n');
+    if (endLine >= lines.length) {
+        return { ...symbol };
+    }
+    const line = lines[endLine];
+    if (!line || endChar >= line.length || line[endChar] !== ';') {
+        return { ...symbol };
+    }
+    const extendedRange = {
+        ...(range ?? {}),
+        end: { line: endLine, character: endChar + 1 }
+    };
+    const locationValue = symbol.location;
+    let updatedLocation = locationValue ?? null;
+    if (isLocationObject(locationValue)) {
+        const locationRange = locationValue.range ?? null;
+        updatedLocation = {
+            ...locationValue,
+            range: {
+                ...(locationRange ?? {}),
+                end: { line: endLine, character: endChar + 1 }
+            }
+        };
+    }
+    return {
+        ...symbol,
+        range: extendedRange,
+        selectionRange: extendedRange,
+        location: updatedLocation
+    };
+}
+function buildInitializeParams(repositoryRoot) {
+    const absoluteRoot = path.resolve(repositoryRoot);
+    const rootUri = pathToFileURL(absoluteRoot).href;
+    return {
+        locale: 'en',
+        processId: process.pid,
+        rootPath: absoluteRoot,
+        rootUri,
+        workspaceFolders: [
+            {
+                uri: rootUri,
+                name: path.basename(absoluteRoot)
+            }
+        ],
+        capabilities: buildClientCapabilities(),
+        initializationOptions: {
+            nixpkgs: { expr: 'import <nixpkgs> { }' },
+            formatting: { command: ['nixpkgs-fmt'] },
+            options: {
+                enable: true,
+                target: {
+                    installable: ''
+                }
+            }
+        }
+    };
+}
+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']
+            },
+            signatureHelp: {
+                dynamicRegistration: true,
+                signatureInformation: {
+                    documentationFormat: ['markdown', 'plaintext'],
+                    parameterInformation: { labelOffsetSupport: true }
+                }
+            },
+            codeAction: {
+                dynamicRegistration: true,
+                codeActionLiteralSupport: {
+                    codeActionKind: {
+                        valueSet: ['', 'quickfix', 'refactor', 'refactor.extract', 'refactor.inline', 'refactor.rewrite', 'source', 'source.organizeImports']
+                    }
+                }
+            },
+            rename: { dynamicRegistration: true, prepareSupport: true }
+        },
+        workspace: {
+            workspaceFolders: true,
+            didChangeConfiguration: { dynamicRegistration: true },
+            configuration: true,
+            symbol: {
+                dynamicRegistration: true,
+                symbolKind: { valueSet: symbolKinds }
+            }
+        }
+    };
+}
+function ensureNixdRuntime() {
+    if (process.env[NIXD_ASSUME_ENV] === '1') {
+        return process.env[NIXD_PATH_ENV] ?? defaultNixdCommand();
+    }
+    if (process.platform === 'win32') {
+        throw new Error('nixd は Windows を公式サポートしていません。WSL または Linux/macOS 上で実行してください。');
+    }
+    ensureNixAvailable();
+    const detected = detectNixdBinary();
+    if (detected) {
+        verifyNixdBinary(detected);
+        return detected;
+    }
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        throw new Error('nixd バイナリが見つかりません。SERENA_SKIP_RUNTIME_INSTALL=0 で自動インストールを許可するか、nixd を手動でインストールしてください。');
+    }
+    const installed = installNixdViaNix();
+    if (installed) {
+        verifyNixdBinary(installed);
+        return installed;
+    }
+    throw new Error('nixd (Nix Language Server) が見つかりません。`nix profile install github:nix-community/nixd` などでインストールし、PATH を更新してください。');
+}
+function ensureNixAvailable() {
+    const result = spawnSync('nix', ['--version'], ensureDefaultSubprocessOptions({ encoding: 'utf-8', timeout: 5000 }));
+    if (result.error || result.status !== 0) {
+        throw new Error('Nix が見つかりません。https://nixos.org/download.html の手順で Nix をセットアップしてください。');
+    }
+}
+function detectNixdBinary() {
+    const overridePath = process.env[NIXD_PATH_ENV];
+    if (overridePath) {
+        return overridePath;
+    }
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    const whichResult = spawnSync(locator, ['nixd'], ensureDefaultSubprocessOptions({ encoding: 'utf-8', timeout: 2000 }));
+    if (whichResult.status === 0 && whichResult.stdout) {
+        const firstLine = whichResult.stdout.split(/\r?\n/)[0]?.trim();
+        if (firstLine) {
+            return firstLine;
+        }
+    }
+    const home = os.homedir();
+    const candidates = [
+        path.join(home, '.local', 'bin', 'nixd'),
+        path.join(home, '.smart-edit', 'language_servers', 'nixd', 'nixd'),
+        path.join(home, '.nix-profile', 'bin', 'nixd'),
+        '/usr/local/bin/nixd',
+        '/run/current-system/sw/bin/nixd',
+        '/opt/homebrew/bin/nixd',
+        '/usr/local/opt/nixd/bin/nixd'
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function installNixdViaNix() {
+    const commands = [
+        { cmd: 'nix', args: ['profile', 'install', 'github:nix-community/nixd'] },
+        { cmd: 'nix-env', args: ['-iA', 'nixpkgs.nixd'] }
+    ];
+    for (const command of commands) {
+        const result = spawnSync(command.cmd, command.args, ensureDefaultSubprocessOptions({ encoding: 'utf-8', timeout: 600_000 }));
+        if (result.status === 0) {
+            const detected = detectNixdBinary();
+            if (detected) {
+                return detected;
+            }
+        }
+    }
+    return null;
+}
+function verifyNixdBinary(binaryPath) {
+    const result = spawnSync(binaryPath, ['--version'], ensureDefaultSubprocessOptions({ encoding: 'utf-8', timeout: 5000 }));
+    if (result.error || result.status !== 0) {
+        throw new Error(`nixd 実行ファイルの検証に失敗しました: ${result.stderr ?? result.stdout ?? ''}`.trim());
+    }
+}
+function extractWindowMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const maybeMessage = payload.message;
+    return typeof maybeMessage === 'string' ? maybeMessage : null;
+}
+function defaultNixdCommand() {
+    return process.platform === 'win32' ? 'nixd.exe' : 'nixd';
+}
+function isLocationObject(value) {
+    return typeof value === 'object' && value !== null;
+}