@nogataka/smart-edit 0.0.14

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

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

package/dist/solidlsp/language_servers/pyright_server.js

@@ -0,0 +1,180 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Language } from '../ls_config.js';
+import { SolidLanguageServer, registerLanguageServer } from '../ls.js';
+import { NodeLanguageServerHandler } from '../ls_handler.js';
+const PYRIGHT_IGNORED_PATTERNS = [
+    '**/__pycache__',
+    '**/.venv',
+    '**/.env',
+    '**/build',
+    '**/dist',
+    '**/.pixi'
+];
+function mergeIgnoredPaths(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const entry of additions) {
+        merged.add(entry);
+    }
+    return Array.from(merged);
+}
+export class PyrightLanguageServer extends SolidLanguageServer {
+    nodeHandler;
+    initialized = false;
+    foundSourceFiles = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, PYRIGHT_IGNORED_PATTERNS)
+        };
+        const handler = new NodeLanguageServerHandler({
+            cmd: 'python -m pyright.langserver --stdio',
+            cwd: repositoryRootPath
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.nodeHandler = handler;
+        this.registerHandlers();
+    }
+    start() {
+        const shouldInitialize = !this.initialized;
+        super.start();
+        if (shouldInitialize) {
+            this.foundSourceFiles = false;
+            this.initializeLanguageServer();
+            this.initialized = true;
+        }
+        return this;
+    }
+    stop(shutdownTimeout = 2.0) {
+        super.stop(shutdownTimeout);
+        this.initialized = false;
+        this.foundSourceFiles = false;
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.nodeHandler.onRequest('client/registerCapability', noop);
+        this.nodeHandler.onRequest('workspace/executeClientCommand', () => []);
+        this.nodeHandler.onNotification('$/progress', noop);
+        this.nodeHandler.onNotification('textDocument/publishDiagnostics', noop);
+        this.nodeHandler.onNotification('language/status', noop);
+        this.nodeHandler.onNotification('language/actionableNotification', noop);
+        this.nodeHandler.onNotification('window/logMessage', (payload) => {
+            const message = extractMessage(payload);
+            if (message) {
+                this.logger.info(`Pyright LSP message: ${message}`);
+                if (/Found \d+ source files?/i.test(message)) {
+                    this.foundSourceFiles = true;
+                }
+            }
+        });
+        this.nodeHandler.onNotification('experimental/serverStatus', (payload) => {
+            const params = payload;
+            if (params?.quiescent && !this.foundSourceFiles) {
+                this.logger.debug('Pyright reported experimental/serverStatus quiescent=true before finding sources.');
+            }
+        });
+    }
+    initializeLanguageServer() {
+        const params = this.buildInitializeParams();
+        const response = this.nodeHandler.sendRequest('initialize', params);
+        if (!response || typeof response !== 'object') {
+            throw new Error('Pyright language server returned an invalid initialize response.');
+        }
+        this.verifyCapabilities(response.capabilities ?? null);
+        this.nodeHandler.notify.initialized({});
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('Pyright initialization response is missing capabilities.');
+        }
+        const hasTextDocumentSync = Object.prototype.hasOwnProperty.call(capabilities, 'textDocumentSync');
+        const hasCompletionProvider = Object.prototype.hasOwnProperty.call(capabilities, 'completionProvider');
+        const hasDefinitionProvider = Object.prototype.hasOwnProperty.call(capabilities, 'definitionProvider');
+        if (!hasTextDocumentSync || !hasCompletionProvider || !hasDefinitionProvider) {
+            throw new Error('Pyright language server does not expose required capabilities.');
+        }
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            processId: process.pid,
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            initializationOptions: {
+                exclude: [
+                    '**/__pycache__',
+                    '**/.venv',
+                    '**/.env',
+                    '**/build',
+                    '**/dist',
+                    '**/.pixi'
+                ],
+                reportMissingImports: 'error'
+            },
+            capabilities: {
+                workspace: {
+                    workspaceEdit: { documentChanges: true },
+                    didChangeConfiguration: { dynamicRegistration: true },
+                    didChangeWatchedFiles: { dynamicRegistration: true },
+                    symbol: {
+                        dynamicRegistration: true,
+                        symbolKind: { valueSet: rangeArray(1, 27) }
+                    },
+                    executeCommand: { dynamicRegistration: true }
+                },
+                textDocument: {
+                    synchronization: {
+                        dynamicRegistration: true,
+                        willSave: true,
+                        willSaveWaitUntil: true,
+                        didSave: true
+                    },
+                    hover: {
+                        dynamicRegistration: true,
+                        contentFormat: ['markdown', 'plaintext']
+                    },
+                    signatureHelp: {
+                        dynamicRegistration: true,
+                        signatureInformation: {
+                            documentationFormat: ['markdown', 'plaintext'],
+                            parameterInformation: { labelOffsetSupport: true }
+                        }
+                    },
+                    definition: { dynamicRegistration: true },
+                    references: { dynamicRegistration: true },
+                    documentSymbol: {
+                        dynamicRegistration: true,
+                        symbolKind: { valueSet: rangeArray(1, 27) },
+                        hierarchicalDocumentSymbolSupport: true
+                    },
+                    publishDiagnostics: { relatedInformation: true }
+                }
+            },
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+}
+function extractMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const message = payload.message;
+    return typeof message === 'string' ? message : null;
+}
+function rangeArray(start, endExclusive) {
+    const values = [];
+    for (let value = start; value < endExclusive; value += 1) {
+        values.push(value);
+    }
+    return values;
+}
+registerLanguageServer(Language.PYTHON, PyrightLanguageServer);

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

@@ -0,0 +1,19 @@
+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 RLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    private initialized;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: number | LogLevel;
+    } | null, repositoryRootPath: string, options?: {
+        timeout?: number | null;
+        solidlspSettings?: SolidLspSettingsInit;
+    });
+    start(): this;
+    stop(shutdownTimeout?: number): void;
+    private registerHandlers;
+    private initializeLanguageServer;
+    private buildInitializeParams;
+    private verifyCapabilities;
+}

package/dist/solidlsp/language_servers/r_language_server.js

@@ -0,0 +1,184 @@
+import { spawnSync } from 'node:child_process';
+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 R_ASSUME_ENV = 'SERENA_ASSUME_R';
+const R_BINARY_ENV = 'SERENA_R_BINARY';
+const DEFAULT_R_BINARY = process.platform === 'win32' ? 'R.exe' : 'R';
+const R_IGNORED_PATTERNS = [
+    '**/renv',
+    '**/renv/**',
+    '**/packrat',
+    '**/packrat/**',
+    '**/.Rproj.user',
+    '**/.Rproj.user/**',
+    '**/vignettes',
+    '**/vignettes/**'
+];
+export class RLanguageServer extends SolidLanguageServer {
+    handler;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        ensureRRuntimeAvailable();
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPatterns(config.ignoredPaths, R_IGNORED_PATTERNS)
+        };
+        const handler = new NodeLanguageServerHandler({
+            cmd: buildRCommand(),
+            cwd: repositoryRootPath
+        }, {
+            requestTimeoutSeconds: options?.timeout ?? null
+        });
+        super(augmentedConfig, loggerLike, repositoryRootPath, {
+            ...options,
+            handler,
+            solidlspSettings: options?.solidlspSettings
+        });
+        this.handler = handler;
+        this.registerHandlers();
+    }
+    start() {
+        const shouldInitialize = !this.initialized;
+        super.start();
+        if (shouldInitialize) {
+            this.initializeLanguageServer();
+            this.initialized = true;
+        }
+        return this;
+    }
+    stop(shutdownTimeout = 2.0) {
+        super.stop(shutdownTimeout);
+        this.initialized = false;
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.handler.onRequest('client/registerCapability', noop);
+        this.handler.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`R language server: ${message}`);
+            }
+        });
+        this.handler.onNotification('$/progress', noop);
+        this.handler.onNotification('textDocument/publishDiagnostics', noop);
+    }
+    initializeLanguageServer() {
+        this.logger.info('Initializing R language server');
+        const params = this.buildInitializeParams();
+        const response = this.handler.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.handler.notify.initialized({});
+    }
+    buildInitializeParams() {
+        const repositoryAbsolutePath = path.resolve(this.repositoryRootPath);
+        const rootUri = pathToFileURL(repositoryAbsolutePath).href;
+        return {
+            locale: 'en',
+            capabilities: buildClientCapabilities(),
+            processId: process.pid,
+            rootPath: repositoryAbsolutePath,
+            rootUri,
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(repositoryAbsolutePath)
+                }
+            ]
+        };
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities || typeof capabilities !== 'object') {
+            throw new Error('R language server did not return capabilities during initialization.');
+        }
+        const textDocumentCaps = capabilities;
+        if (!Object.prototype.hasOwnProperty.call(textDocumentCaps, 'textDocumentSync')) {
+            throw new Error('R language server initialization response is missing textDocumentSync capability.');
+        }
+    }
+}
+function ensureRRuntimeAvailable() {
+    if (process.env[R_ASSUME_ENV] === '1') {
+        return;
+    }
+    const binary = process.env[R_BINARY_ENV] ?? DEFAULT_R_BINARY;
+    const versionResult = spawnSync(binary, ['--version'], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (versionResult.error || versionResult.status !== 0) {
+        throw new Error('R が見つかりません。https://www.r-project.org/ から R をインストールし、PATH に追加してください。');
+    }
+    const packageCheck = spawnSync(binary, [
+        '--vanilla',
+        '--quiet',
+        '--slave',
+        '-e',
+        "if (!require('languageserver', quietly=TRUE)) quit(status=1)"
+    ], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (packageCheck.error || packageCheck.status !== 0) {
+        throw new Error('R languageserver パッケージが見つかりません。`R -e "install.packages(\'languageserver\')"` でインストールしてください。');
+    }
+}
+function buildRCommand() {
+    const binary = process.env[R_BINARY_ENV] ?? DEFAULT_R_BINARY;
+    return [
+        binary,
+        '--vanilla',
+        '--quiet',
+        '--slave',
+        '-e',
+        'options(languageserver.debug_mode = FALSE); languageserver::run()'
+    ];
+}
+function mergeIgnoredPatterns(existing, additions) {
+    const merged = new Set(existing ?? []);
+    for (const pattern of additions) {
+        merged.add(pattern);
+    }
+    return Array.from(merged);
+}
+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 },
+            completion: {
+                dynamicRegistration: true,
+                completionItem: {
+                    snippetSupport: true,
+                    commitCharactersSupport: true,
+                    documentationFormat: ['markdown', 'plaintext'],
+                    deprecatedSupport: true,
+                    preselectSupport: true
+                }
+            },
+            hover: { dynamicRegistration: true, contentFormat: ['markdown', 'plaintext'] },
+            definition: { dynamicRegistration: true },
+            references: { dynamicRegistration: true },
+            documentSymbol: {
+                dynamicRegistration: true,
+                hierarchicalDocumentSymbolSupport: true,
+                symbolKind: { valueSet: symbolKinds }
+            },
+            formatting: { dynamicRegistration: true },
+            rangeFormatting: { dynamicRegistration: true }
+        },
+        workspace: {
+            workspaceFolders: true,
+            didChangeConfiguration: { dynamicRegistration: true },
+            symbol: {
+                dynamicRegistration: true,
+                symbolKind: { valueSet: symbolKinds }
+            }
+        }
+    };
+}
+registerLanguageServer(Language.R, RLanguageServer);

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

@@ -0,0 +1,10 @@
+import type { SerenaLogger } from '../../serena/util/logging.js';
+export declare const RUBY_BINARY_ENV = "SERENA_RUBY_BINARY";
+export declare const BUNDLE_BINARY_ENV = "SERENA_BUNDLE_BINARY";
+export declare function resolveRubyBinary(): string;
+export declare function ensureRubyAvailable(logger: SerenaLogger, repositoryRootPath: string): void;
+export declare function findCommand(command: string): string | null;
+export declare function findBundleExecutable(repositoryRootPath: string): string | null;
+export declare function gemfileLockContains(gemfileLockPath: string, gemName: string): boolean;
+export declare function installGem(gemName: string, logger: SerenaLogger, repositoryRootPath: string): void;
+export declare function buildRubyExcludePatterns(repositoryRootPath: string): string[];

package/dist/solidlsp/language_servers/ruby_common.js

@@ -0,0 +1,136 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensureDefaultSubprocessOptions } from '../util/subprocess_util.js';
+export const RUBY_BINARY_ENV = 'SERENA_RUBY_BINARY';
+export const BUNDLE_BINARY_ENV = 'SERENA_BUNDLE_BINARY';
+const DEFAULT_RUBY_BINARY = process.platform === 'win32' ? 'ruby.exe' : 'ruby';
+const DEFAULT_BUNDLE_CANDIDATES = process.platform === 'win32'
+    ? ['bundle.bat', 'bundle.cmd', 'bundle.exe', 'bundle']
+    : ['bundle'];
+export function resolveRubyBinary() {
+    const raw = process.env[RUBY_BINARY_ENV];
+    const trimmed = raw?.trim();
+    return trimmed ?? DEFAULT_RUBY_BINARY;
+}
+export function ensureRubyAvailable(logger, repositoryRootPath) {
+    const rubyBinary = resolveRubyBinary();
+    const versionResult = spawnSync(rubyBinary, ['--version'], ensureDefaultSubprocessOptions({
+        cwd: repositoryRootPath,
+        encoding: 'utf-8'
+    }));
+    if (versionResult.error || versionResult.status !== 0) {
+        const detailSource = versionResult.stderr ??
+            versionResult.stdout ??
+            versionResult.error?.message ??
+            '';
+        const detail = detailSource.trim();
+        throw new Error(`Ruby が見つかりませんでした。${detail ? `詳細: ${detail}。` : ''}Ruby をインストールし PATH に追加してください。`);
+    }
+    const output = (versionResult.stdout || versionResult.stderr || '').trim();
+    if (output) {
+        logger.info(`検出した Ruby: ${output}`);
+    }
+}
+export function findCommand(command) {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(locator, [command], ensureDefaultSubprocessOptions({ encoding: 'utf-8' }));
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    const stdout = result.stdout ?? '';
+    const line = stdout
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .find((entry) => entry.length > 0);
+    return line ?? null;
+}
+export function findBundleExecutable(repositoryRootPath) {
+    const override = process.env[BUNDLE_BINARY_ENV]?.trim();
+    if (override) {
+        return override;
+    }
+    for (const candidate of DEFAULT_BUNDLE_CANDIDATES) {
+        const localPath = path.join(repositoryRootPath, 'bin', candidate);
+        if (fs.existsSync(localPath)) {
+            return localPath;
+        }
+    }
+    for (const candidate of DEFAULT_BUNDLE_CANDIDATES) {
+        const resolved = findCommand(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+export function gemfileLockContains(gemfileLockPath, gemName) {
+    if (!fs.existsSync(gemfileLockPath)) {
+        return false;
+    }
+    try {
+        const content = fs.readFileSync(gemfileLockPath, 'utf-8');
+        return content.toLowerCase().includes(gemName.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+export function installGem(gemName, logger, repositoryRootPath) {
+    if (process.env.SERENA_SKIP_RUNTIME_INSTALL === '1') {
+        throw new Error(`${gemName} が見つかりません。SERENA_SKIP_RUNTIME_INSTALL=1 を解除するか、` +
+            `gem install ${gemName} を手動で実行してください。`);
+    }
+    logger.info(`gem install ${gemName} を試行します`);
+    const installResult = spawnSync('gem', ['install', gemName], ensureDefaultSubprocessOptions({
+        cwd: repositoryRootPath,
+        encoding: 'utf-8'
+    }));
+    if (installResult.error || installResult.status !== 0) {
+        const detail = `${installResult.stdout ?? ''}${installResult.stderr ?? ''}`.trim();
+        throw new Error(`gem install ${gemName} に失敗しました。${detail ? `詳細: ${detail}` : 'gem が利用可能か確認してください。'}`);
+    }
+    logger.info(`gem install ${gemName} が成功しました。`);
+}
+export function buildRubyExcludePatterns(repositoryRootPath) {
+    const basePatterns = [
+        '**/vendor/**',
+        '**/.bundle/**',
+        '**/tmp/**',
+        '**/log/**',
+        '**/coverage/**',
+        '**/.yardoc/**',
+        '**/doc/**',
+        '**/.git/**',
+        '**/node_modules/**',
+        '**/public/assets/**'
+    ];
+    if (isRailsProject(repositoryRootPath)) {
+        basePatterns.push('**/app/assets/builds/**', '**/storage/**', '**/public/packs/**', '**/public/webpack/**');
+    }
+    return basePatterns;
+}
+function isRailsProject(repositoryRootPath) {
+    const indicators = [
+        path.join('config', 'application.rb'),
+        path.join('config', 'environment.rb'),
+        path.join('app', 'controllers', 'application_controller.rb'),
+        'Rakefile'
+    ];
+    for (const relative of indicators) {
+        if (fs.existsSync(path.join(repositoryRootPath, relative))) {
+            return true;
+        }
+    }
+    const gemfilePath = path.join(repositoryRootPath, 'Gemfile');
+    if (!fs.existsSync(gemfilePath)) {
+        return false;
+    }
+    try {
+        const content = fs.readFileSync(gemfilePath, 'utf-8').toLowerCase();
+        return content.includes("gem 'rails'") || content.includes('gem "rails"');
+    }
+    catch {
+        return false;
+    }
+}

package/dist/solidlsp/language_servers/ruby_lsp.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 RubyLspLanguageServer 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;
+}