@nogataka/smart-edit 0.0.14

package/dist/solidlsp/language_servers/erlang_language_server.js

@@ -0,0 +1,327 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+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';
+const DEFAULT_REQUEST_TIMEOUT_SECONDS = 120;
+const ERLANG_IGNORED_DIRECTORIES = [
+    '_build',
+    'deps',
+    'ebin',
+    '.rebar3',
+    'logs',
+    'node_modules',
+    '_checkouts',
+    'cover'
+];
+const READINESS_KEYWORDS = [
+    'Started Erlang LS',
+    'server started',
+    'initialized',
+    'ready to serve requests',
+    'compilation finished',
+    'indexing complete'
+];
+export class ErlangLanguageServer extends SolidLanguageServer {
+    handler;
+    initialized = false;
+    readyPromise;
+    readyResolver = null;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const requestTimeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_SECONDS;
+        const runtime = ensureErlangRuntime();
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, ERLANG_IGNORED_DIRECTORIES)
+        };
+        const providedHandler = options.handler;
+        if (providedHandler && !(providedHandler instanceof NodeLanguageServerHandler)) {
+            throw new TypeError('ErlangLanguageServer requires a NodeLanguageServerHandler when supplying a custom handler.');
+        }
+        const handlerInstance = providedHandler ?? new NodeLanguageServerHandler({
+            cmd: [runtime.binaryPath, '--transport', 'stdio'],
+            cwd: repositoryRootPath
+        }, {
+            requestTimeoutSeconds: requestTimeout
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            timeout: requestTimeout,
+            solidlspSettings: options?.solidlspSettings,
+            handler: handlerInstance
+        });
+        if (runtime.erlangVersion) {
+            this.logger.info(`Detected Erlang runtime: ${runtime.erlangVersion}`);
+        }
+        if (!runtime.hasRebar3) {
+            this.logger.warn('rebar3 command not found. Some Erlang LS features may be degraded.');
+        }
+        this.handler = handlerInstance;
+        this.readyPromise = this.createReadyPromise();
+        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;
+        this.readyPromise = this.createReadyPromise();
+    }
+    initializeLanguageServer() {
+        this.logger.info('Initializing Erlang LS');
+        const params = this.buildInitializeParams();
+        const response = this.handler.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.handler.notify.initialized({});
+        this.waitForReadiness();
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            processId: process.pid,
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            locale: 'en',
+            capabilities: buildClientCapabilities(),
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('Erlang LS initialize response is missing capabilities.');
+        }
+        const textDocumentCaps = capabilities.textDocument;
+        if (!textDocumentCaps) {
+            throw new Error('Erlang LS did not report textDocument capabilities.');
+        }
+        const requiredKeys = ['synchronization', 'completion', 'definition', 'references', 'documentSymbol', 'hover'];
+        for (const key of requiredKeys) {
+            if (!(key in textDocumentCaps)) {
+                throw new Error(`Erlang LS capabilities missing '${key}' under textDocument.`);
+            }
+        }
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onNotification('window/logMessage', (payload) => {
+            this.handleWindowLogMessage(payload);
+        });
+        this.handler.onNotification('$/progress', (payload) => {
+            this.handleProgressNotification(payload);
+        });
+        this.handler.onNotification('window/workDoneProgress/create', noop);
+        this.handler.onNotification('$/workDoneProgress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+    }
+    handleWindowLogMessage(payload) {
+        const message = extractMessage(payload);
+        if (!message) {
+            return;
+        }
+        this.logger.info(`Erlang LS: ${message}`);
+        const normalized = message.toLowerCase();
+        if (READINESS_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+            this.logger.info(`Erlang LS readiness signal detected: ${message}`);
+            this.markServerReady();
+        }
+    }
+    handleProgressNotification(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return;
+        }
+        const params = payload;
+        const progress = params.value;
+        if (progress?.kind?.toLowerCase() === 'end') {
+            const message = progress.message ?? '';
+            if (containsReadinessKeyword(message)) {
+                this.logger.info('Erlang LS initialization progress reported completion.');
+                this.markServerReady();
+            }
+        }
+    }
+    waitForReadiness() {
+        const isCi = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+        const isMacOs = process.platform === 'darwin';
+        const readyTimeoutSeconds = isCi ? (isMacOs ? 240 : 180) : 60;
+        const settlingSeconds = isCi ? 15 : 5;
+        const fallbackSettlingSeconds = isCi ? 20 : 10;
+        this.logger.info(`Waiting up to ${readyTimeoutSeconds} seconds for Erlang LS readiness (${isCi ? (isMacOs ? 'macOS CI' : 'CI') : 'local'} environment).`);
+        void (async () => {
+            const readinessOutcome = await Promise.race([
+                this.readyPromise.then(() => 'ready'),
+                delay(readyTimeoutSeconds * 1000).then(() => 'timeout')
+            ]);
+            if (readinessOutcome === 'ready') {
+                this.logger.info('Erlang LS reported readiness. Allowing additional settling time.');
+                await delay(settlingSeconds * 1000);
+                this.logger.info('Erlang LS settling period complete.');
+            }
+            else {
+                this.logger.warn(`Erlang LS readiness timeout reached after ${readyTimeoutSeconds}s, proceeding anyway (common in CI environments).`);
+                this.markServerReady();
+                await delay(fallbackSettlingSeconds * 1000);
+                this.logger.info('Basic Erlang LS initialization period complete.');
+            }
+        })().catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn(`Erlang LS readiness watcher encountered an error: ${message}`);
+        });
+    }
+    markServerReady() {
+        const resolver = this.readyResolver;
+        if (!resolver) {
+            return;
+        }
+        this.readyResolver = null;
+        resolver();
+    }
+    createReadyPromise() {
+        return new Promise((resolve) => {
+            this.readyResolver = () => {
+                this.readyResolver = null;
+                resolve();
+            };
+        });
+    }
+}
+function ensureErlangRuntime() {
+    if (shouldAssumeInstalled()) {
+        return {
+            binaryPath: getAssumedBinaryPath(),
+            hasRebar3: true,
+            erlangVersion: null
+        };
+    }
+    const binaryPath = findExecutable(['erlang_ls', process.platform === 'win32' ? 'erlang_ls.cmd' : null]);
+    if (!binaryPath) {
+        throw new Error('Erlang LS not found. Install from https://github.com/erlang-ls/erlang_ls and ensure it is on PATH.');
+    }
+    if (!commandSucceeds('erl', ['-version'])) {
+        throw new Error('Erlang/OTP not found. Install from https://www.erlang.org/downloads and ensure it is on PATH.');
+    }
+    const erlangVersion = captureCommandOutput('erl', ['-version']);
+    const hasRebar3 = commandSucceeds('rebar3', ['version']);
+    return {
+        binaryPath,
+        hasRebar3,
+        erlangVersion: erlangVersion ?? null
+    };
+}
+function shouldAssumeInstalled() {
+    return process.env.SERENA_ASSUME_ERLANG === '1' || process.env.SERENA_ASSUME_ERLANG_LS === '1';
+}
+function getAssumedBinaryPath() {
+    const override = process.env.SERENA_ERLANG_LS_PATH;
+    if (override) {
+        return override;
+    }
+    if (process.platform === 'win32') {
+        return 'erlang_ls.cmd';
+    }
+    return 'erlang_ls';
+}
+function commandSucceeds(command, args) {
+    const result = spawnSync(command, args, ensureDefaultSubprocessOptions({ stdio: 'ignore' }));
+    return result.status === 0;
+}
+function captureCommandOutput(command, args) {
+    const result = spawnSync(command, args, ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status !== 0) {
+        return null;
+    }
+    const stdout = typeof result.stdout === 'string' ? result.stdout.trim() : '';
+    const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
+    return stdout || stderr || null;
+}
+function findExecutable(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate) {
+            continue;
+        }
+        const overridePath = process.env.SERENA_ERLANG_LS_PATH;
+        if (overridePath && fs.existsSync(overridePath)) {
+            return overridePath;
+        }
+        const resolved = whichBinary(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+function whichBinary(command) {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(locator, [command], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.status === 0 && typeof result.stdout === 'string') {
+        const [first] = result.stdout.split(/\r?\n/u);
+        if (first && first.trim().length > 0) {
+            return first.trim();
+        }
+    }
+    return null;
+}
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+        merged.add(`**/${entry}/**`);
+    }
+    return Array.from(merged);
+}
+function buildClientCapabilities() {
+    return {
+        textDocument: {
+            synchronization: { didSave: true, dynamicRegistration: true },
+            completion: { dynamicRegistration: true },
+            definition: { dynamicRegistration: true },
+            references: { dynamicRegistration: true },
+            documentSymbol: { dynamicRegistration: true },
+            hover: { dynamicRegistration: true }
+        },
+        workspace: {
+            workspaceFolders: true,
+            configuration: true
+        }
+    };
+}
+function extractMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const raw = payload.message;
+    return typeof raw === 'string' ? raw : null;
+}
+function containsReadinessKeyword(message) {
+    const normalized = message.toLowerCase();
+    return READINESS_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()));
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        const timer = globalThis.setTimeout(resolve, ms);
+        if (isUnrefableTimeout(timer)) {
+            timer.unref();
+        }
+    });
+}
+function isUnrefableTimeout(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    return 'unref' in value && typeof value.unref === 'function';
+}
+registerLanguageServer(Language.ERLANG, ErlangLanguageServer);

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

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

package/dist/solidlsp/language_servers/gopls.js

@@ -0,0 +1,59 @@
+import { spawnSync } from 'node:child_process';
+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 commandExists(command) {
+    if (process.env.SERENA_ASSUME_GOPLS === '1') {
+        return true;
+    }
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    return spawnSync(locator, [command], ensureDefaultSubprocessOptions({ stdio: 'ignore' })).status === 0;
+}
+function ensureGoRuntime() {
+    if (!commandExists('go')) {
+        throw new Error('Go is not installed. Install Go from https://golang.org/doc/install and ensure it is in PATH.');
+    }
+    if (!commandExists('gopls')) {
+        throw new Error('gopls is not installed. Install it via `go install golang.org/x/tools/gopls@latest` and ensure it is available in PATH.');
+    }
+}
+function mergeIgnored(existing) {
+    const merged = new Set(existing ?? []);
+    ['vendor', 'node_modules', 'dist', 'build'].forEach((entry) => merged.add(entry));
+    return Array.from(merged);
+}
+export class GoplsLanguageServer extends SolidLanguageServer {
+    handler;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        ensureGoRuntime();
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnored(config.ignoredPaths)
+        };
+        const handler = new NodeLanguageServerHandler({
+            cmd: 'gopls',
+            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(`gopls: ${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.GO, GoplsLanguageServer);

package/dist/solidlsp/language_servers/intelephense.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 IntelephenseLanguageServer 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/intelephense.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 INTELEPHENSE_DEPENDENCIES = [
+    {
+        id: 'intelephense',
+        command: 'npm install --prefix ./ intelephense@1.14.4',
+        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_INTELEPHENSE === '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, 'php-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, 'intelephense.cmd');
+        if (fs.existsSync(cmdPath)) {
+            return cmdPath;
+        }
+        const ps1Path = path.join(base, 'intelephense.ps1');
+        if (fs.existsSync(ps1Path)) {
+            return ps1Path;
+        }
+    }
+    return path.join(base, 'intelephense');
+}
+function ensureIntelephenseBinary(runtimeDir, dependencies, loggerLevel) {
+    const { logger } = createSerenaLogger({
+        name: 'solidlsp.language_servers.intelephense',
+        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(`Intelephense executable not found at ${binaryPath}. Allow downloads by unsetting SERENA_SKIP_RUNTIME_INSTALL or install manually.`);
+    }
+    ensureNodeTooling();
+    logger.info('Installing intelephense via npm');
+    dependencies.install(logger, runtimeDir);
+    if (!fs.existsSync(binaryPath)) {
+        throw new Error(`Intelephense 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', 'vendor', 'cache'].forEach((entry) => merged.add(entry));
+    return Array.from(merged);
+}
+export class IntelephenseLanguageServer 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(INTELEPHENSE_DEPENDENCIES);
+        const binaryPath = ensureIntelephenseBinary(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(`intelephense: ${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.PHP, IntelephenseLanguageServer);

package/dist/solidlsp/language_servers/jedi_server.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 JediLanguageServer extends SolidLanguageServer {
+    private readonly nodeHandler;
+    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 verifyCapabilities;
+    private buildInitializeParams;
+}