@nogataka/smart-edit 0.0.14

package/dist/solidlsp/language_servers/jedi_server.js

@@ -0,0 +1,234 @@
+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 JEDI_IGNORED_PATTERNS = ['**/venv', '**/.venv', '**/__pycache__'];
+export class JediLanguageServer extends SolidLanguageServer {
+    nodeHandler;
+    initialized = false;
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        const augmentedConfig = {
+            ...config,
+            ignoredPaths: mergeIgnoredPaths(config.ignoredPaths, JEDI_IGNORED_PATTERNS)
+        };
+        const handler = new NodeLanguageServerHandler({
+            cmd: 'jedi-language-server',
+            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.initializeLanguageServer();
+            this.initialized = true;
+        }
+        return this;
+    }
+    stop(shutdownTimeout = 2.0) {
+        super.stop(shutdownTimeout);
+        this.initialized = false;
+    }
+    registerHandlers() {
+        const noop = () => undefined;
+        this.nodeHandler.onRequest('client/registerCapability', noop);
+        this.nodeHandler.onNotification('language/status', noop);
+        this.nodeHandler.onNotification('$/progress', noop);
+        this.nodeHandler.onNotification('textDocument/publishDiagnostics', noop);
+        this.nodeHandler.onNotification('language/actionableNotification', noop);
+        this.nodeHandler.onNotification('experimental/serverStatus', (payload) => {
+            const params = payload;
+            if (params?.quiescent) {
+                this.logger.debug('jedi-language-server reported experimental/serverStatus quiescent=true');
+            }
+        });
+        this.nodeHandler.onRequest('workspace/executeClientCommand', () => []);
+        this.nodeHandler.onNotification('window/logMessage', (payload) => {
+            const message = extractWindowMessage(payload);
+            if (message) {
+                this.logger.info(`Jedi LSP message: ${message}`);
+            }
+        });
+    }
+    initializeLanguageServer() {
+        this.logger.info('Initializing jedi-language-server');
+        const params = this.buildInitializeParams();
+        const response = this.nodeHandler.sendRequest('initialize', params);
+        this.verifyCapabilities(response?.capabilities ?? null);
+        this.nodeHandler.notify.initialized({});
+    }
+    verifyCapabilities(capabilities) {
+        if (!capabilities) {
+            throw new Error('Jedi language server initialization response is missing capabilities.');
+        }
+        const { textDocumentSync, completionProvider } = capabilities;
+        if (textDocumentSync?.change !== 2) {
+            throw new Error('Jedi language server does not advertise required textDocumentSync capability.');
+        }
+        if (completionProvider?.resolveProvider !== true) {
+            throw new Error('Jedi language server does not expose a resolve-capable completion provider.');
+        }
+        const triggerCandidates = completionProvider?.triggerCharacters;
+        const triggerCharacters = Array.isArray(triggerCandidates)
+            ? triggerCandidates
+            : [];
+        for (const expected of [".", "'", "\""]) {
+            if (!triggerCharacters.includes(expected)) {
+                throw new Error(`Jedi language server missing completion trigger character "${expected}".`);
+            }
+        }
+    }
+    buildInitializeParams() {
+        const rootUri = pathToFileURL(this.repositoryRootPath).href;
+        return {
+            processId: process.pid,
+            clientInfo: { name: 'Serena', version: '0.1.0' },
+            locale: 'en',
+            rootPath: this.repositoryRootPath,
+            rootUri,
+            capabilities: buildCapabilities(),
+            initializationOptions: {
+                workspace: {
+                    symbols: {
+                        ignoreFolders: ['.nox', '.tox', '.venv', '__pycache__', 'venv'],
+                        maxSymbols: 0
+                    }
+                }
+            },
+            trace: 'verbose',
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: path.basename(this.repositoryRootPath)
+                }
+            ]
+        };
+    }
+}
+function mergeIgnoredPaths(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 buildCapabilities() {
+    const symbolKinds = rangeArray(1, 27);
+    return {
+        workspace: {
+            applyEdit: true,
+            workspaceEdit: {
+                documentChanges: true,
+                resourceOperations: ['create', 'rename', 'delete'],
+                failureHandling: 'textOnlyTransactional',
+                normalizesLineEndings: true,
+                changeAnnotationSupport: { groupsOnLabel: true }
+            },
+            configuration: true,
+            didChangeWatchedFiles: { dynamicRegistration: true, relativePatternSupport: true },
+            symbol: {
+                dynamicRegistration: true,
+                symbolKind: { valueSet: symbolKinds },
+                tagSupport: { valueSet: [1] },
+                resolveSupport: { properties: ['location.range'] }
+            },
+            workspaceFolders: true,
+            fileOperations: {
+                dynamicRegistration: true,
+                didCreate: true,
+                didRename: true,
+                didDelete: true,
+                willCreate: true,
+                willRename: true,
+                willDelete: true
+            },
+            inlineValue: { refreshSupport: true },
+            inlayHint: { refreshSupport: true },
+            diagnostics: { refreshSupport: true }
+        },
+        textDocument: {
+            publishDiagnostics: {
+                relatedInformation: true,
+                versionSupport: false,
+                tagSupport: { valueSet: [1, 2] },
+                codeDescriptionSupport: true,
+                dataSupport: true
+            },
+            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 },
+                    activeParameterSupport: true
+                },
+                contextSupport: true
+            },
+            definition: { dynamicRegistration: true, linkSupport: true },
+            references: { dynamicRegistration: true },
+            documentHighlight: { dynamicRegistration: true },
+            documentSymbol: {
+                dynamicRegistration: true,
+                symbolKind: { valueSet: symbolKinds },
+                hierarchicalDocumentSymbolSupport: true,
+                tagSupport: { valueSet: [1] },
+                labelSupport: true
+            },
+            documentLink: { dynamicRegistration: true, tooltipSupport: true },
+            typeDefinition: { dynamicRegistration: true, linkSupport: true },
+            implementation: { dynamicRegistration: true, linkSupport: true },
+            declaration: { dynamicRegistration: true, linkSupport: true },
+            selectionRange: { dynamicRegistration: true },
+            callHierarchy: { dynamicRegistration: true },
+            linkedEditingRange: { dynamicRegistration: true },
+            typeHierarchy: { dynamicRegistration: true },
+            inlineValue: { dynamicRegistration: true },
+            inlayHint: {
+                dynamicRegistration: true,
+                resolveSupport: {
+                    properties: ['tooltip', 'textEdits', 'label.tooltip', 'label.location', 'label.command']
+                }
+            },
+            diagnostic: { dynamicRegistration: true, relatedDocumentSupport: false }
+        },
+        notebookDocument: {
+            synchronization: {
+                dynamicRegistration: true,
+                executionSummarySupport: true
+            }
+        },
+        experimental: {
+            serverStatusNotification: true,
+            openServerLogs: true
+        }
+    };
+}
+function rangeArray(start, endExclusive) {
+    const values = [];
+    for (let value = start; value < endExclusive; value += 1) {
+        values.push(value);
+    }
+    return values;
+}
+registerLanguageServer(Language.PYTHON_JEDI, JediLanguageServer);

package/dist/solidlsp/language_servers/kotlin_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 KotlinLanguageServer extends SolidLanguageServer {
+    protected readonly handler: NodeLanguageServerHandler;
+    private readonly runtimePaths;
+    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;
+}