@nogataka/smart-edit 0.0.14

package/dist/solidlsp/ls.d.ts

@@ -0,0 +1,197 @@
+import { MatchedConsecutiveLines } from '../serena/text_utils.js';
+import { type LogLevel, type SerenaLogger } from '../serena/util/logging.js';
+import { type PathMatcher } from '../serena/util/file_system.js';
+import type { Language } from './ls_config.js';
+export interface LanguageServerConfig {
+    codeLanguage: Language;
+    traceLspCommunication?: boolean;
+    startIndependentLspProcess?: boolean;
+    ignoredPaths?: string[];
+}
+export interface LanguageServerConfigLike {
+    codeLanguage: Language;
+    traceLspCommunication?: boolean;
+    startIndependentLspProcess?: boolean;
+    ignoredPaths?: string[];
+}
+export interface SolidLspSettingsInit {
+    solidlspDir?: string;
+    projectDataRelativePath?: string;
+    lsSpecificSettings?: Record<string, unknown>;
+}
+export declare class SolidLspSettings {
+    readonly solidlspDir: string;
+    readonly projectDataRelativePath: string;
+    readonly lsSpecificSettings: Record<string, unknown>;
+    constructor(init?: SolidLspSettingsInit);
+    get languageServersStaticDir(): string;
+}
+export declare function coerceLogLevel(value: LogLevel | number | undefined): LogLevel;
+export interface LspRange {
+    start?: {
+        line?: number;
+        character?: number | null;
+    } | null;
+    end?: {
+        line?: number;
+        character?: number | null;
+    } | null;
+}
+export interface UnifiedSymbolInformation {
+    name: string;
+    kind: number;
+    children?: UnifiedSymbolInformation[];
+    location?: {
+        relativePath?: string | null;
+        range?: LspRange | null;
+    } | null;
+    parent?: UnifiedSymbolInformation | null;
+    range?: LspRange | null;
+    selectionRange?: LspRange | null;
+    body?: string;
+}
+export interface ReferenceInSymbol {
+    symbol: UnifiedSymbolInformation;
+    line: number;
+    character: number;
+}
+export interface DocumentSymbolsOptions {
+    includeBody?: boolean;
+}
+export interface FullSymbolTreeOptions {
+    withinRelativePath?: string;
+    includeBody?: boolean;
+}
+export interface ReferencingSymbolsOptions {
+    relativeFilePath: string;
+    line: number;
+    column: number;
+    includeImports?: boolean;
+    includeSelf?: boolean;
+    includeBody?: boolean;
+    includeFileSymbols?: boolean;
+}
+export interface DidOpenTextDocumentParams {
+    textDocument: {
+        uri: string;
+        languageId: string;
+        version: number;
+        text: string;
+    };
+}
+export interface DidChangeTextDocumentParams {
+    textDocument: {
+        uri: string;
+        version: number;
+    };
+    contentChanges: {
+        range: {
+            start: {
+                line: number;
+                character: number;
+            };
+            end: {
+                line: number;
+                character: number;
+            };
+        };
+        text: string;
+    }[];
+}
+export interface DidCloseTextDocumentParams {
+    textDocument: {
+        uri: string;
+    };
+}
+export interface DocumentSymbolResult {
+    documentSymbols: UnifiedSymbolInformation[];
+    outlineSymbols: UnifiedSymbolInformation[];
+}
+export interface SolidLanguageServerNotifications {
+    initialized(params: unknown): void;
+    exit(): void;
+    didOpenTextDocument(params: DidOpenTextDocumentParams): void;
+    didChangeTextDocument(params: DidChangeTextDocumentParams): void;
+    didCloseTextDocument(params: DidCloseTextDocumentParams): void;
+}
+export interface SolidLanguageServerRequests {
+    documentSymbol(params: {
+        textDocument: {
+            uri: string;
+        };
+        options?: DocumentSymbolsOptions;
+    }): DocumentSymbolResult | null;
+    fullSymbolTree(params: FullSymbolTreeOptions): UnifiedSymbolInformation[] | null;
+    referencingSymbols(options: ReferencingSymbolsOptions): ReferenceInSymbol[] | null;
+    overview(relativeFilePath: string): Record<string, UnifiedSymbolInformation[]> | null;
+    shutdown(): void;
+}
+export interface SolidLanguageServerHandler {
+    setRequestTimeout(timeout: number | null): void;
+    isRunning(): boolean;
+    start(): void;
+    shutdown(): void;
+    dispose(): void;
+    readonly notify: SolidLanguageServerNotifications;
+    readonly send: SolidLanguageServerRequests;
+}
+export interface SolidLanguageServerOptions {
+    timeout?: number | null;
+    solidlspSettings?: SolidLspSettingsInit;
+    handler?: SolidLanguageServerHandler;
+}
+export type SolidLanguageServerConstructor = new (config: LanguageServerConfigLike, loggerLike: {
+    level?: LogLevel | number;
+} | null, repositoryRootPath: string, options?: SolidLanguageServerOptions) => SolidLanguageServer;
+export declare class SolidLanguageServer {
+    static readonly CACHE_FOLDER_NAME = "cache";
+    protected readonly repositoryRootPath: string;
+    protected readonly logger: SerenaLogger;
+    protected readonly language: Language;
+    private readonly languageMatcher;
+    private readonly ignoreMatcher;
+    protected readonly handler: SolidLanguageServerHandler;
+    protected readonly solidlspSettings: SolidLspSettings;
+    private readonly documentSymbolsCache;
+    private serverStarted;
+    private cacheHasChanged;
+    private readonly openFileBuffers;
+    constructor(config: LanguageServerConfigLike, loggerLike: {
+        level?: LogLevel | number;
+    } | null, repositoryRootPath: string, options?: SolidLanguageServerOptions);
+    static create(config: LanguageServerConfigLike, loggerLike: {
+        level?: LogLevel | number;
+    } | null, repositoryRootPath: string, options?: SolidLanguageServerOptions): SolidLanguageServer;
+    start(): this;
+    stop(shutdownTimeout?: number): void;
+    isRunning(): boolean;
+    setRequestTimeout(timeout: number | null): void;
+    getRepositoryRootPath(): string;
+    get ignoreSpec(): PathMatcher;
+    saveCache(): void;
+    requestDocumentSymbols(relativePath: string, options?: DocumentSymbolsOptions): DocumentSymbolResult;
+    requestFullSymbolTree(options?: FullSymbolTreeOptions): UnifiedSymbolInformation[];
+    requestReferencingSymbols(options: ReferencingSymbolsOptions): ReferenceInSymbol[];
+    requestOverview(relativePath: string): Record<string, UnifiedSymbolInformation[]>;
+    retrieveFullFileContent(relativePath: string): string;
+    retrieveContentAroundLine(relativePath: string, line: number, contextLinesBefore?: number, contextLinesAfter?: number): MatchedConsecutiveLines;
+    insertTextAtPosition(relativePath: string, line: number, column: number, text: string): {
+        line: number;
+        column: number;
+    };
+    deleteTextBetweenPositions(relativePath: string, start: {
+        line: number;
+        character: number;
+    }, end: {
+        line: number;
+        character: number;
+    }): string;
+    isIgnoredPath(relativePath: string, ignoreUnsupportedFiles?: boolean): boolean;
+    private ensureServerRunning;
+    private withOpenFile;
+    private acquireFileBuffer;
+    private releaseFileBuffer;
+    private loadCache;
+    private get cachePath();
+}
+export declare function registerLanguageServer(language: Language, ctor: SolidLanguageServerConstructor): void;

package/dist/solidlsp/ls.js

@@ -0,0 +1,507 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import ignore from 'ignore';
+import { MatchedConsecutiveLines } from '../serena/text_utils.js';
+import { createSerenaLogger } from '../serena/util/logging.js';
+import { matchPath } from '../serena/util/file_system.js';
+import { getLanguageFilenameMatcher } from './ls_config.js';
+export class SolidLspSettings {
+    solidlspDir;
+    projectDataRelativePath;
+    lsSpecificSettings;
+    constructor(init = {}) {
+        this.solidlspDir = init.solidlspDir ?? path.join(path.resolve(process.env.HOME ?? '.'), '.solidlsp');
+        this.projectDataRelativePath = init.projectDataRelativePath ?? '.solidlsp';
+        this.lsSpecificSettings = { ...(init.lsSpecificSettings ?? {}) };
+        fs.mkdirSync(this.solidlspDir, { recursive: true });
+        fs.mkdirSync(this.languageServersStaticDir, { recursive: true });
+    }
+    get languageServersStaticDir() {
+        return path.join(this.solidlspDir, 'language_servers', 'static');
+    }
+}
+function logWithLevel(logger, level, message, meta) {
+    switch (level) {
+        case 'trace':
+            logger.trace(message, meta);
+            break;
+        case 'debug':
+            logger.debug(message, meta);
+            break;
+        case 'info':
+            logger.info(message, meta);
+            break;
+        case 'warn':
+            logger.warn(message, meta);
+            break;
+        case 'error':
+            logger.error(message, meta);
+            break;
+        case 'fatal':
+            logger.fatal(message, meta);
+            break;
+        default:
+            logger.info(message, meta);
+    }
+}
+export function coerceLogLevel(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (value <= 10) {
+            return 'trace';
+        }
+        if (value <= 20) {
+            return 'debug';
+        }
+        if (value <= 30) {
+            return 'info';
+        }
+        if (value <= 40) {
+            return 'warn';
+        }
+        if (value <= 50) {
+            return 'error';
+        }
+        return 'fatal';
+    }
+    return 'info';
+}
+class NullLanguageServerHandler {
+    running = false;
+    timeout = null;
+    setRequestTimeout(timeout) {
+        this.timeout = timeout ?? null;
+    }
+    isRunning() {
+        return this.running;
+    }
+    start() {
+        this.running = true;
+    }
+    shutdown() {
+        this.running = false;
+    }
+    dispose() {
+        this.timeout = null;
+    }
+    notify = {
+        initialized: (params) => {
+            void params;
+        },
+        exit: () => {
+            // no-op
+        },
+        didOpenTextDocument: (params) => {
+            void params;
+        },
+        didChangeTextDocument: (params) => {
+            void params;
+        },
+        didCloseTextDocument: (params) => {
+            void params;
+        }
+    };
+    send = {
+        documentSymbol: () => null,
+        fullSymbolTree: () => null,
+        referencingSymbols: () => null,
+        overview: () => ({}),
+        shutdown: () => undefined
+    };
+}
+class LspFileBuffer {
+    uri;
+    contents;
+    version;
+    languageId;
+    refCount;
+    contentHash;
+    constructor(init) {
+        this.uri = init.uri;
+        this.contents = init.contents;
+        this.version = init.version;
+        this.languageId = init.languageId;
+        this.refCount = init.refCount;
+        this.contentHash = computeContentHash(this.contents);
+    }
+    updateContents(contents) {
+        this.contents = contents;
+        this.contentHash = computeContentHash(contents);
+    }
+}
+function computeContentHash(contents) {
+    return createHash('md5').update(contents, 'utf8').digest('hex');
+}
+function normalizeRelativePath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    if (normalized.startsWith('./')) {
+        return normalized.slice(2);
+    }
+    if (normalized.startsWith('../')) {
+        return normalized.replace(/^\\.\\./u, '..');
+    }
+    return normalized;
+}
+function getIndexFromLineCol(text, line, col) {
+    let currentLine = 0;
+    let currentCol = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (currentLine === line && currentCol === col) {
+            return index;
+        }
+        const char = text[index];
+        if (char === '\n') {
+            currentLine += 1;
+            currentCol = 0;
+        }
+        else if (char === '\r') {
+            continue;
+        }
+        else {
+            currentCol += 1;
+        }
+    }
+    if (currentLine === line && currentCol === col) {
+        return text.length;
+    }
+    throw new RangeError(`Position (${line}, ${col}) is out of bounds.`);
+}
+function insertTextAtPosition(text, line, col, snippet) {
+    const index = getIndexFromLineCol(text, line, col);
+    const updated = `${text.slice(0, index)}${snippet}${text.slice(index)}`;
+    const lines = snippet.split('\n');
+    if (lines.length === 1) {
+        return { contents: updated, line, column: col + snippet.length };
+    }
+    const newLine = line + lines.length - 1;
+    const newColumn = lines[lines.length - 1].length;
+    return { contents: updated, line: newLine, column: newColumn };
+}
+function deleteTextBetweenPositions(text, start, end) {
+    const startIndex = getIndexFromLineCol(text, start.line, start.character);
+    const endIndex = getIndexFromLineCol(text, end.line, end.character);
+    if (endIndex < startIndex) {
+        throw new RangeError('End position must not precede start position.');
+    }
+    const deleted = text.slice(startIndex, endIndex);
+    const updated = `${text.slice(0, startIndex)}${text.slice(endIndex)}`;
+    return { contents: updated, deleted };
+}
+export class SolidLanguageServer {
+    static CACHE_FOLDER_NAME = 'cache';
+    repositoryRootPath;
+    logger;
+    language;
+    languageMatcher;
+    ignoreMatcher;
+    handler;
+    solidlspSettings;
+    documentSymbolsCache = new Map();
+    serverStarted = false;
+    cacheHasChanged = false;
+    openFileBuffers = new Map();
+    constructor(config, loggerLike, repositoryRootPath, options = {}) {
+        this.repositoryRootPath = path.resolve(repositoryRootPath);
+        this.language = config.codeLanguage;
+        this.languageMatcher = getLanguageFilenameMatcher(this.language);
+        const ignoredPatterns = Array.from(new Set(config.ignoredPaths ?? [])).map((pattern) => pattern.replace(/\\/g, '/'));
+        const ignoreInstance = ignore();
+        if (ignoredPatterns.length > 0) {
+            ignoreInstance.add(ignoredPatterns);
+        }
+        this.ignoreMatcher = {
+            ignores(candidate) {
+                const normalizedCandidate = candidate.replace(/^\/+/, '');
+                return ignoreInstance.ignores(normalizedCandidate);
+            }
+        };
+        const { logger } = createSerenaLogger({
+            level: coerceLogLevel(loggerLike?.level),
+            emitToConsole: false,
+            name: 'solidlsp.language_server'
+        });
+        this.logger = logger;
+        this.handler = options.handler ?? new NullLanguageServerHandler();
+        if (options.timeout !== undefined) {
+            this.handler.setRequestTimeout(options.timeout ?? null);
+        }
+        this.solidlspSettings = new SolidLspSettings(options.solidlspSettings);
+        this.loadCache();
+    }
+    static create(config, loggerLike, repositoryRootPath, options = {}) {
+        const Ctor = getLanguageServerConstructor(config.codeLanguage);
+        return new Ctor(config, loggerLike, repositoryRootPath, options);
+    }
+    start() {
+        if (this.serverStarted) {
+            return this;
+        }
+        logWithLevel(this.logger, 'info', `Starting SolidLanguageServer for ${this.repositoryRootPath}`);
+        this.handler.start();
+        this.serverStarted = true;
+        return this;
+    }
+    stop(shutdownTimeout = 2.0) {
+        if (!this.serverStarted) {
+            return;
+        }
+        logWithLevel(this.logger, 'debug', `Stopping SolidLanguageServer (timeout=${shutdownTimeout}s)`);
+        for (const buffer of this.openFileBuffers.values()) {
+            this.handler.notify.didCloseTextDocument({
+                textDocument: { uri: buffer.uri }
+            });
+        }
+        this.openFileBuffers.clear();
+        this.handler.shutdown();
+        this.handler.dispose();
+        this.serverStarted = false;
+    }
+    isRunning() {
+        return this.handler.isRunning();
+    }
+    setRequestTimeout(timeout) {
+        this.handler.setRequestTimeout(timeout);
+    }
+    getRepositoryRootPath() {
+        return this.repositoryRootPath;
+    }
+    get ignoreSpec() {
+        return this.ignoreMatcher;
+    }
+    saveCache() {
+        if (!this.cacheHasChanged) {
+            return;
+        }
+        const cachePath = this.cachePath;
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        const payload = {};
+        for (const [relativePath, entry] of this.documentSymbolsCache.entries()) {
+            payload[relativePath] = {
+                hash: entry.hash,
+                data: {
+                    documentSymbols: entry.data.documentSymbols,
+                    outlineSymbols: entry.data.outlineSymbols
+                }
+            };
+        }
+        fs.writeFileSync(cachePath, JSON.stringify(payload, null, 2), { encoding: 'utf-8' });
+        this.cacheHasChanged = false;
+    }
+    requestDocumentSymbols(relativePath, options = {}) {
+        this.ensureServerRunning('requestDocumentSymbols');
+        return this.withOpenFile(relativePath, (buffer) => {
+            const cached = this.documentSymbolsCache.get(relativePath);
+            if (cached && cached.hash === buffer.contentHash) {
+                return {
+                    documentSymbols: cloneSymbols(cached.data.documentSymbols),
+                    outlineSymbols: cloneSymbols(cached.data.outlineSymbols)
+                };
+            }
+            const response = this.handler.send.documentSymbol({
+                textDocument: { uri: buffer.uri },
+                options
+            });
+            const result = response ?? {
+                documentSymbols: [],
+                outlineSymbols: []
+            };
+            this.documentSymbolsCache.set(relativePath, {
+                hash: buffer.contentHash,
+                data: {
+                    documentSymbols: cloneSymbols(result.documentSymbols),
+                    outlineSymbols: cloneSymbols(result.outlineSymbols)
+                }
+            });
+            this.cacheHasChanged = true;
+            return result;
+        });
+    }
+    requestFullSymbolTree(options = {}) {
+        this.ensureServerRunning('requestFullSymbolTree');
+        const response = this.handler.send.fullSymbolTree(options);
+        return response ? cloneSymbols(response) : [];
+    }
+    requestReferencingSymbols(options) {
+        this.ensureServerRunning('requestReferencingSymbols');
+        const response = this.handler.send.referencingSymbols(options);
+        return response ? response.map((entry) => ({ ...entry, symbol: cloneSymbol(entry.symbol) })) : [];
+    }
+    requestOverview(relativePath) {
+        this.ensureServerRunning('requestOverview');
+        const response = this.handler.send.overview(relativePath) ?? {};
+        const clone = {};
+        for (const [key, symbols] of Object.entries(response)) {
+            clone[key] = cloneSymbols(symbols);
+        }
+        return clone;
+    }
+    retrieveFullFileContent(relativePath) {
+        return this.withOpenFile(relativePath, (buffer) => buffer.contents);
+    }
+    retrieveContentAroundLine(relativePath, line, contextLinesBefore = 0, contextLinesAfter = 0) {
+        const contents = this.retrieveFullFileContent(relativePath);
+        return MatchedConsecutiveLines.fromFileContents({
+            fileContents: contents,
+            line,
+            contextLinesBefore,
+            contextLinesAfter,
+            sourceFilePath: relativePath
+        });
+    }
+    insertTextAtPosition(relativePath, line, column, text) {
+        this.ensureServerRunning('insertTextAtPosition');
+        return this.withOpenFile(relativePath, (buffer) => {
+            const result = insertTextAtPosition(buffer.contents, line, column, text);
+            buffer.updateContents(result.contents);
+            buffer.version += 1;
+            this.handler.notify.didChangeTextDocument({
+                textDocument: { uri: buffer.uri, version: buffer.version },
+                contentChanges: [
+                    {
+                        range: {
+                            start: { line, character: column },
+                            end: { line, character: column }
+                        },
+                        text
+                    }
+                ]
+            });
+            return { line: result.line, column: result.column };
+        });
+    }
+    deleteTextBetweenPositions(relativePath, start, end) {
+        this.ensureServerRunning('deleteTextBetweenPositions');
+        return this.withOpenFile(relativePath, (buffer) => {
+            const { contents, deleted } = deleteTextBetweenPositions(buffer.contents, start, end);
+            buffer.updateContents(contents);
+            buffer.version += 1;
+            this.handler.notify.didChangeTextDocument({
+                textDocument: { uri: buffer.uri, version: buffer.version },
+                contentChanges: [
+                    {
+                        range: {
+                            start,
+                            end
+                        },
+                        text: ''
+                    }
+                ]
+            });
+            return deleted;
+        });
+    }
+    isIgnoredPath(relativePath, ignoreUnsupportedFiles = true) {
+        const normalized = normalizeRelativePath(relativePath);
+        const absolutePath = path.resolve(this.repositoryRootPath, normalized);
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`File ${absolutePath} not found, the ignore check cannot be performed`);
+        }
+        const stats = fs.statSync(absolutePath);
+        if (stats.isFile() && ignoreUnsupportedFiles) {
+            if (!this.languageMatcher.isRelevantFilename(path.basename(absolutePath))) {
+                return true;
+            }
+        }
+        return matchPath(normalized, this.ignoreMatcher, this.repositoryRootPath);
+    }
+    ensureServerRunning(operation) {
+        if (!this.serverStarted) {
+            throw new Error(`Language server is not started; cannot call ${operation}`);
+        }
+    }
+    withOpenFile(relativePath, handler) {
+        const buffer = this.acquireFileBuffer(relativePath);
+        try {
+            return handler(buffer);
+        }
+        finally {
+            this.releaseFileBuffer(buffer.uri);
+        }
+    }
+    acquireFileBuffer(relativePath) {
+        const normalized = normalizeRelativePath(relativePath);
+        const absolutePath = path.resolve(this.repositoryRootPath, normalized);
+        const uri = pathToFileURL(absolutePath).href;
+        const existing = this.openFileBuffers.get(uri);
+        if (existing) {
+            existing.refCount += 1;
+            return existing;
+        }
+        const contents = fs.readFileSync(absolutePath, { encoding: 'utf-8' });
+        const buffer = new LspFileBuffer({ uri, contents, version: 0, languageId: this.language, refCount: 1 });
+        this.openFileBuffers.set(uri, buffer);
+        this.handler.notify.didOpenTextDocument({
+            textDocument: {
+                uri,
+                languageId: this.language,
+                version: buffer.version,
+                text: contents
+            }
+        });
+        return buffer;
+    }
+    releaseFileBuffer(uri) {
+        const buffer = this.openFileBuffers.get(uri);
+        if (!buffer) {
+            return;
+        }
+        buffer.refCount -= 1;
+        if (buffer.refCount <= 0) {
+            this.handler.notify.didCloseTextDocument({
+                textDocument: { uri }
+            });
+            this.openFileBuffers.delete(uri);
+        }
+    }
+    loadCache() {
+        const cachePath = this.cachePath;
+        if (!fs.existsSync(cachePath)) {
+            return;
+        }
+        try {
+            const contents = fs.readFileSync(cachePath, 'utf-8');
+            const parsed = JSON.parse(contents);
+            for (const [relativePath, entry] of Object.entries(parsed)) {
+                this.documentSymbolsCache.set(relativePath, {
+                    hash: entry.hash,
+                    data: {
+                        documentSymbols: cloneSymbols(entry.data.documentSymbols),
+                        outlineSymbols: cloneSymbols(entry.data.outlineSymbols)
+                    }
+                });
+            }
+        }
+        catch (error) {
+            logWithLevel(this.logger, 'warn', `Failed to load SolidLSP cache from ${cachePath}`, error);
+        }
+    }
+    get cachePath() {
+        return path.join(this.repositoryRootPath, this.solidlspSettings.projectDataRelativePath, SolidLanguageServer.CACHE_FOLDER_NAME, this.language, 'document_symbols_cache.json');
+    }
+}
+const LANGUAGE_SERVER_REGISTRY = new Map();
+export function registerLanguageServer(language, ctor) {
+    LANGUAGE_SERVER_REGISTRY.set(language, ctor);
+}
+function getLanguageServerConstructor(language) {
+    return LANGUAGE_SERVER_REGISTRY.get(language) ?? SolidLanguageServer;
+}
+function deepClone(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+function cloneSymbol(symbol) {
+    return {
+        ...symbol,
+        children: symbol.children ? cloneSymbols(symbol.children) : undefined,
+        parent: symbol.parent ?? undefined,
+        location: symbol.location ? deepClone(symbol.location) : undefined,
+        selectionRange: symbol.selectionRange ? deepClone(symbol.selectionRange) : undefined
+    };
+}
+function cloneSymbols(symbols) {
+    return symbols.map((symbol) => cloneSymbol(symbol));
+}