@nogataka/smart-edit 0.0.14

package/dist/serena/symbol.js

@@ -0,0 +1,616 @@
+import path from 'node:path';
+import { createSerenaLogger } from './util/logging.js';
+const { logger } = createSerenaLogger({ name: 'serena.symbol', emitToConsole: false, level: 'info' });
+export var SymbolKind;
+(function (SymbolKind) {
+    SymbolKind[SymbolKind["File"] = 1] = "File";
+    SymbolKind[SymbolKind["Module"] = 2] = "Module";
+    SymbolKind[SymbolKind["Namespace"] = 3] = "Namespace";
+    SymbolKind[SymbolKind["Package"] = 4] = "Package";
+    SymbolKind[SymbolKind["Class"] = 5] = "Class";
+    SymbolKind[SymbolKind["Method"] = 6] = "Method";
+    SymbolKind[SymbolKind["Property"] = 7] = "Property";
+    SymbolKind[SymbolKind["Field"] = 8] = "Field";
+    SymbolKind[SymbolKind["Constructor"] = 9] = "Constructor";
+    SymbolKind[SymbolKind["Enum"] = 10] = "Enum";
+    SymbolKind[SymbolKind["Interface"] = 11] = "Interface";
+    SymbolKind[SymbolKind["Function"] = 12] = "Function";
+    SymbolKind[SymbolKind["Variable"] = 13] = "Variable";
+    SymbolKind[SymbolKind["Constant"] = 14] = "Constant";
+    SymbolKind[SymbolKind["String"] = 15] = "String";
+    SymbolKind[SymbolKind["Number"] = 16] = "Number";
+    SymbolKind[SymbolKind["Boolean"] = 17] = "Boolean";
+    SymbolKind[SymbolKind["Array"] = 18] = "Array";
+    SymbolKind[SymbolKind["Object"] = 19] = "Object";
+    SymbolKind[SymbolKind["Key"] = 20] = "Key";
+    SymbolKind[SymbolKind["Null"] = 21] = "Null";
+    SymbolKind[SymbolKind["EnumMember"] = 22] = "EnumMember";
+    SymbolKind[SymbolKind["Struct"] = 23] = "Struct";
+    SymbolKind[SymbolKind["Event"] = 24] = "Event";
+    SymbolKind[SymbolKind["Operator"] = 25] = "Operator";
+    SymbolKind[SymbolKind["TypeParameter"] = 26] = "TypeParameter";
+})(SymbolKind || (SymbolKind = {}));
+export class LanguageServerSymbolLocation {
+    relativePath;
+    line;
+    column;
+    constructor(init) {
+        this.relativePath = init.relativePath ? init.relativePath.replace(/\//g, path.sep) : null;
+        this.line = init.line ?? null;
+        this.column = init.column ?? null;
+    }
+    toDict(options = {}) {
+        const includeRelativePath = options.includeRelativePath ?? true;
+        const payload = {
+            relative_path: includeRelativePath ? this.relativePath : undefined,
+            line: this.line,
+            column: this.column
+        };
+        if (!includeRelativePath) {
+            delete payload.relative_path;
+        }
+        return payload;
+    }
+    to_dict(options) {
+        return this.toDict({ includeRelativePath: options?.include_relative_path });
+    }
+    hasPositionInFile() {
+        return this.relativePath !== null && this.line !== null && this.column !== null;
+    }
+    has_position_in_file() {
+        return this.hasPositionInFile();
+    }
+}
+export class PositionInFile {
+    line;
+    col;
+    constructor(init) {
+        this.line = init.line;
+        this.col = init.col;
+    }
+    toLspPosition() {
+        return { line: this.line, character: this.col };
+    }
+    to_lsp_position() {
+        return this.toLspPosition();
+    }
+}
+export class Symbol {
+    getBodyStartPositionOrRaise() {
+        const position = this.getBodyStartPosition();
+        if (!position) {
+            throw new Error(`Body start position is not defined for ${this.constructor.name}`);
+        }
+        return position;
+    }
+    getBodyEndPositionOrRaise() {
+        const position = this.getBodyEndPosition();
+        if (!position) {
+            throw new Error(`Body end position is not defined for ${this.constructor.name}`);
+        }
+        return position;
+    }
+    get_body_start_position() {
+        return this.getBodyStartPosition();
+    }
+    get_body_end_position() {
+        return this.getBodyEndPosition();
+    }
+    get_body_start_position_or_raise() {
+        return this.getBodyStartPositionOrRaise();
+    }
+    get_body_end_position_or_raise() {
+        return this.getBodyEndPositionOrRaise();
+    }
+    is_neighbouring_definition_separated_by_empty_line() {
+        return this.isNeighbouringDefinitionSeparatedByEmptyLine();
+    }
+}
+function normalizeRelativePath(candidate) {
+    if (candidate === null || candidate === undefined) {
+        return null;
+    }
+    return candidate.replace(/\//g, path.sep);
+}
+function resolveSymbolLocation(raw) {
+    if (raw.location && typeof raw.location === 'object') {
+        return raw.location;
+    }
+    return null;
+}
+function resolveSelectionRange(raw) {
+    if (raw.selectionRange && typeof raw.selectionRange === 'object') {
+        return raw.selectionRange;
+    }
+    return null;
+}
+export class LanguageServerSymbol extends Symbol {
+    static NAME_PATH_SEPARATOR = '/';
+    symbolRoot;
+    constructor(symbolRoot) {
+        super();
+        this.symbolRoot = symbolRoot;
+    }
+    static matchNamePath(namePath, symbolNamePathParts, substringMatching) {
+        if (!namePath) {
+            throw new Error('name_path must not be empty');
+        }
+        if (!symbolNamePathParts || symbolNamePathParts.length === 0) {
+            throw new Error('symbol_name_path_parts must not be empty');
+        }
+        const sep = LanguageServerSymbol.NAME_PATH_SEPARATOR;
+        const isAbsolutePattern = namePath.startsWith(sep);
+        const patternParts = namePath
+            .replace(/^\/*/u, '')
+            .replace(/\/*$/u, '')
+            .split(sep)
+            .filter((part) => part.length > 0);
+        if (patternParts.length === 0) {
+            return true;
+        }
+        if (patternParts.length > symbolNamePathParts.length) {
+            return false;
+        }
+        if (isAbsolutePattern && patternParts.length !== symbolNamePathParts.length) {
+            return false;
+        }
+        const expectedAncestors = patternParts.slice(0, -1);
+        const candidateAncestors = symbolNamePathParts.slice(-patternParts.length, -1);
+        if (expectedAncestors.length > 0 && expectedAncestors.join('\u0000') !== candidateAncestors.join('\u0000')) {
+            return false;
+        }
+        const needle = patternParts[patternParts.length - 1] ?? '';
+        const haystack = symbolNamePathParts[symbolNamePathParts.length - 1] ?? '';
+        return substringMatching ? haystack.includes(needle) : haystack === needle;
+    }
+    get name() {
+        return this.symbolRoot.name ?? '';
+    }
+    get kind() {
+        return SymbolKind[this.symbolKind] ?? 'Unknown';
+    }
+    get symbolKind() {
+        const rawKind = this.symbolRoot.kind;
+        if (typeof rawKind === 'number' && rawKind in SymbolKind) {
+            return rawKind;
+        }
+        return SymbolKind.Object;
+    }
+    get relativePath() {
+        const location = resolveSymbolLocation(this.symbolRoot);
+        if (!location) {
+            return null;
+        }
+        return normalizeRelativePath(location.relativePath ?? null);
+    }
+    get location() {
+        return new LanguageServerSymbolLocation({
+            relativePath: this.relativePath,
+            line: this.line,
+            column: this.column
+        });
+    }
+    get body() {
+        const body = this.symbolRoot.body;
+        return typeof body === 'string' ? body : undefined;
+    }
+    get line() {
+        const selection = resolveSelectionRange(this.symbolRoot);
+        if (selection?.start?.line !== undefined) {
+            return selection.start.line;
+        }
+        return null;
+    }
+    get column() {
+        const selection = resolveSelectionRange(this.symbolRoot);
+        if (selection?.start?.character !== undefined) {
+            return selection.start.character;
+        }
+        return null;
+    }
+    isNeighbouringDefinitionSeparatedByEmptyLine() {
+        return (this.symbolKind === SymbolKind.Function ||
+            this.symbolKind === SymbolKind.Method ||
+            this.symbolKind === SymbolKind.Class ||
+            this.symbolKind === SymbolKind.Interface ||
+            this.symbolKind === SymbolKind.Struct);
+    }
+    getBodyStartPosition() {
+        const location = resolveSymbolLocation(this.symbolRoot);
+        const start = location?.range?.start;
+        if (!start) {
+            return null;
+        }
+        return new PositionInFile({ line: start.line ?? 0, col: start.character ?? 0 });
+    }
+    getBodyEndPosition() {
+        const location = resolveSymbolLocation(this.symbolRoot);
+        const end = location?.range?.end;
+        if (!end) {
+            return null;
+        }
+        return new PositionInFile({ line: end.line ?? 0, col: end.character ?? 0 });
+    }
+    getBodyLineNumbers() {
+        const range = resolveSymbolLocation(this.symbolRoot)?.range;
+        const startLine = range?.start?.line ?? null;
+        const endLine = range?.end?.line ?? null;
+        return [startLine, endLine];
+    }
+    getBodyStartPositionOrRaise() {
+        return super.getBodyStartPositionOrRaise();
+    }
+    getBodyEndPositionOrRaise() {
+        return super.getBodyEndPositionOrRaise();
+    }
+    get_name_path() {
+        return this.getNamePath();
+    }
+    getNamePath() {
+        return this.getNamePathParts().join(LanguageServerSymbol.NAME_PATH_SEPARATOR);
+    }
+    getNamePathParts() {
+        const ancestors = Array.from(this.iterAncestors(SymbolKind.File)).reverse();
+        const ancestorNames = ancestors.map((ancestor) => ancestor.name);
+        return [...ancestorNames, this.name];
+    }
+    get_name_path_parts() {
+        return this.getNamePathParts();
+    }
+    *iterChildren() {
+        const children = Array.isArray(this.symbolRoot.children) ? this.symbolRoot.children : [];
+        for (const child of children) {
+            if (child) {
+                yield new LanguageServerSymbol(child);
+            }
+        }
+    }
+    iter_children() {
+        return this.iterChildren();
+    }
+    *iterAncestors(upToSymbolKind) {
+        const parent = this.getParent();
+        if (!parent) {
+            return;
+        }
+        if (upToSymbolKind === undefined || parent.symbolKind !== upToSymbolKind) {
+            yield parent;
+            yield* parent.iterAncestors(upToSymbolKind);
+        }
+    }
+    iter_ancestors(upToSymbolKind) {
+        return this.iterAncestors(upToSymbolKind);
+    }
+    getParent() {
+        const parent = this.symbolRoot.parent;
+        if (!parent) {
+            return null;
+        }
+        return new LanguageServerSymbol(parent);
+    }
+    get_parent() {
+        return this.getParent();
+    }
+    find(namePath, options = {}) {
+        const { substringMatching = false, includeKinds, excludeKinds } = options;
+        const include = includeKinds ? new Set(includeKinds.map((kind) => Number(kind))) : null;
+        const exclude = excludeKinds ? new Set(excludeKinds.map((kind) => Number(kind))) : null;
+        const result = [];
+        const shouldInclude = (symbol) => {
+            if (include?.has(symbol.symbolKind) === false) {
+                return false;
+            }
+            if (exclude?.has(symbol.symbolKind)) {
+                return false;
+            }
+            return LanguageServerSymbol.matchNamePath(namePath, symbol.getNamePathParts(), substringMatching);
+        };
+        const traverse = (symbol) => {
+            if (shouldInclude(symbol)) {
+                result.push(symbol);
+            }
+            for (const child of symbol.iterChildren()) {
+                traverse(child);
+            }
+        };
+        traverse(this);
+        return result;
+    }
+    find_symbols(namePath, substringMatching = false, includeKinds, excludeKinds) {
+        return this.find(namePath, { substringMatching, includeKinds, excludeKinds });
+    }
+    toDict(options = {}) {
+        const { kind = false, location = false, depth = 0, includeBody = false, includeChildrenBody = false, includeRelativePath = true } = options;
+        const result = {
+            name: this.name,
+            name_path: this.getNamePath()
+        };
+        if (kind) {
+            result.kind = this.kind;
+        }
+        if (location) {
+            result.location = this.location.toDict({ includeRelativePath });
+            const [startLine, endLine] = this.getBodyLineNumbers();
+            result.body_location = { start_line: startLine, end_line: endLine };
+        }
+        if (includeBody) {
+            if (this.body === undefined) {
+                logger.warn(`Requested body for symbol ${this.name}, but it is not present. The symbol might have been loaded without include_body.`);
+            }
+            result.body = this.body ?? null;
+        }
+        if (depth > 0) {
+            result.children = this.collectChildren({
+                depth,
+                includeBody: includeChildrenBody,
+                includeLocation: location,
+                includeKind: kind
+            });
+        }
+        return result;
+    }
+    to_dict(options) {
+        return this.toDict({
+            kind: options?.kind,
+            location: options?.location,
+            depth: options?.depth,
+            includeBody: options?.include_body,
+            includeChildrenBody: options?.include_children_body,
+            includeRelativePath: options?.include_relative_path
+        });
+    }
+    collectChildren(options) {
+        const { depth, includeBody, includeLocation, includeKind } = options;
+        const result = [];
+        if (depth <= 0) {
+            return result;
+        }
+        for (const child of this.iterChildren()) {
+            result.push(child.toDict({
+                kind: includeKind,
+                location: includeLocation,
+                depth: depth - 1,
+                includeBody,
+                includeChildrenBody: includeBody,
+                includeRelativePath: false
+            }));
+        }
+        return result;
+    }
+}
+export class ReferenceInLanguageServerSymbol {
+    symbol;
+    line;
+    character;
+    constructor(init) {
+        this.symbol = init.symbol;
+        this.line = init.line;
+        this.character = init.character;
+    }
+    static fromLspReference(reference) {
+        return new ReferenceInLanguageServerSymbol({
+            symbol: new LanguageServerSymbol(reference.symbol),
+            line: reference.line,
+            character: reference.character
+        });
+    }
+    get_relative_path() {
+        return this.symbol.location.relativePath;
+    }
+}
+function toNumberKindSet(values) {
+    if (!values || values.length === 0) {
+        return null;
+    }
+    return new Set(values.map((value) => Number(value)));
+}
+export class LanguageServerSymbolRetriever {
+    _langServer;
+    agent;
+    constructor(langServer, agent = null) {
+        this._langServer = langServer;
+        this.agent = agent;
+    }
+    setLanguageServer(langServer) {
+        this._langServer = langServer;
+    }
+    set_language_server(langServer) {
+        this.setLanguageServer(langServer);
+    }
+    getLanguageServer() {
+        return this._langServer;
+    }
+    get_language_server() {
+        return this.getLanguageServer();
+    }
+    findByName(namePath, options = {}) {
+        const { includeBody = false, includeKinds, excludeKinds, substringMatching = false, withinRelativePath } = options;
+        const symbolRoots = this._langServer.requestFullSymbolTree({
+            withinRelativePath: withinRelativePath ?? undefined,
+            includeBody
+        });
+        const includeSet = toNumberKindSet(includeKinds);
+        const excludeSet = toNumberKindSet(excludeKinds);
+        const matches = [];
+        for (const root of symbolRoots) {
+            const symbol = new LanguageServerSymbol(root);
+            const found = symbol.find(namePath, {
+                includeKinds: includeSet ? Array.from(includeSet) : undefined,
+                excludeKinds: excludeSet ? Array.from(excludeSet) : undefined,
+                substringMatching
+            });
+            matches.push(...found);
+        }
+        return matches;
+    }
+    find_by_name(namePath, includeBody = false, includeKinds, excludeKinds, substringMatching = false, withinRelativePath) {
+        return this.findByName(namePath, {
+            includeBody,
+            includeKinds,
+            excludeKinds,
+            substringMatching,
+            withinRelativePath
+        });
+    }
+    getDocumentSymbols(relativePath) {
+        const result = this._langServer.requestDocumentSymbols(relativePath, { includeBody: false });
+        return result.documentSymbols.map((entry) => new LanguageServerSymbol(entry));
+    }
+    get_document_symbols(relativePath) {
+        return this.getDocumentSymbols(relativePath);
+    }
+    findByLocation(location) {
+        if (!location.relativePath) {
+            return null;
+        }
+        const result = this._langServer.requestDocumentSymbols(location.relativePath, { includeBody: false });
+        for (const symbolDict of result.documentSymbols) {
+            const symbol = new LanguageServerSymbol(symbolDict);
+            if (symbol.location.relativePath === location.relativePath && symbol.line === location.line) {
+                return symbol;
+            }
+        }
+        return null;
+    }
+    find_by_location(location) {
+        return this.findByLocation(location);
+    }
+    findReferencingSymbols(namePath, relativeFilePath, options = {}) {
+        const { includeBody = false, includeKinds, excludeKinds } = options;
+        const matches = this.findByName(namePath, {
+            includeBody,
+            includeKinds,
+            excludeKinds,
+            withinRelativePath: relativeFilePath
+        });
+        if (matches.length === 0) {
+            return [];
+        }
+        const target = matches[0];
+        const references = this._langServer.requestReferencingSymbols({
+            relativeFilePath,
+            line: target.line ?? 0,
+            column: target.column ?? 0,
+            includeBody,
+            includeImports: false,
+            includeSelf: false,
+            includeFileSymbols: true
+        });
+        const includeSet = toNumberKindSet(includeKinds);
+        const excludeSet = toNumberKindSet(excludeKinds);
+        return references
+            .filter((reference) => {
+            const symbol = new LanguageServerSymbol(reference.symbol);
+            if (includeSet?.has(symbol.symbolKind) === false) {
+                return false;
+            }
+            if (excludeSet?.has(symbol.symbolKind)) {
+                return false;
+            }
+            return true;
+        })
+            .map((reference) => ReferenceInLanguageServerSymbol.fromLspReference(reference));
+    }
+    find_referencing_symbols(namePath, relativeFilePath, includeBody = false, includeKinds, excludeKinds) {
+        return this.findReferencingSymbols(namePath, relativeFilePath, {
+            includeBody,
+            includeKinds,
+            excludeKinds
+        });
+    }
+    findReferencingSymbolsByLocation(location, options = {}) {
+        if (!location.hasPositionInFile()) {
+            throw new Error('Symbol location does not contain a valid position in a file.');
+        }
+        const references = this._langServer.requestReferencingSymbols({
+            relativeFilePath: location.relativePath ?? '',
+            line: location.line ?? 0,
+            column: location.column ?? 0,
+            includeBody: options.includeBody ?? false,
+            includeImports: false,
+            includeSelf: false,
+            includeFileSymbols: true
+        });
+        const includeSet = toNumberKindSet(options.includeKinds);
+        const excludeSet = toNumberKindSet(options.excludeKinds);
+        return references
+            .filter((reference) => {
+            const symbol = new LanguageServerSymbol(reference.symbol);
+            if (includeSet?.has(symbol.symbolKind) === false) {
+                return false;
+            }
+            if (excludeSet?.has(symbol.symbolKind)) {
+                return false;
+            }
+            return true;
+        })
+            .map((reference) => ReferenceInLanguageServerSymbol.fromLspReference(reference));
+    }
+    find_referencing_symbols_by_location(location, includeBody = false, includeKinds, excludeKinds) {
+        return this.findReferencingSymbolsByLocation(location, {
+            includeBody,
+            includeKinds,
+            excludeKinds
+        });
+    }
+    static symbolOverviewFromSymbol(symbol) {
+        return {
+            name_path: symbol.getNamePath(),
+            kind: Number(symbol.symbolKind)
+        };
+    }
+    getSymbolOverview(relativePath) {
+        const overview = this._langServer.requestOverview(relativePath);
+        const result = {};
+        for (const filePath of Object.keys(overview)) {
+            const symbols = overview[filePath] ?? [];
+            const mappedSymbols = symbols.map((symbol) => LanguageServerSymbolRetriever.symbolOverviewFromSymbol(new LanguageServerSymbol(symbol)));
+            result[filePath] = mappedSymbols;
+        }
+        return result;
+    }
+    get_symbol_overview(relativePath) {
+        return this.getSymbolOverview(relativePath);
+    }
+}
+export class JetBrainsSymbol extends Symbol {
+    data;
+    constructor(symbolDict) {
+        super();
+        this.data = { ...symbolDict };
+    }
+    ensureTextRange() {
+        const textRange = this.data.text_range;
+        if (!textRange || typeof textRange !== 'object') {
+            return null;
+        }
+        const startPos = textRange.start_pos;
+        const endPos = textRange.end_pos;
+        if (!startPos || !endPos) {
+            return null;
+        }
+        return { start_pos: startPos, end_pos: endPos };
+    }
+    getBodyStartPosition() {
+        const range = this.ensureTextRange();
+        if (!range) {
+            return null;
+        }
+        return new PositionInFile({ line: Number(range.start_pos.line ?? 0), col: Number(range.start_pos.col ?? 0) });
+    }
+    getBodyEndPosition() {
+        const range = this.ensureTextRange();
+        if (!range) {
+            return null;
+        }
+        return new PositionInFile({ line: Number(range.end_pos.line ?? 0), col: Number(range.end_pos.col ?? 0) });
+    }
+    isNeighbouringDefinitionSeparatedByEmptyLine() {
+        return true;
+    }
+}
+export class JetBrainsCodeEditorNotAvailableError extends Error {
+    constructor() {
+        super('JetBrains IDE integration is not available in the current TypeScript port.');
+    }
+}

package/dist/serena/text_utils.d.ts

@@ -0,0 +1,51 @@
+export declare enum LineType {
+    MATCH = "match",
+    BEFORE_MATCH = "prefix",
+    AFTER_MATCH = "postfix"
+}
+export declare class TextLine {
+    readonly lineNumber: number;
+    readonly lineContent: string;
+    readonly matchType: LineType;
+    constructor(options: {
+        lineNumber: number;
+        lineContent: string;
+        matchType: LineType;
+    });
+    private getDisplayPrefix;
+    formatLine(includeLineNumbers?: boolean): string;
+}
+export declare class MatchedConsecutiveLines {
+    readonly lines: TextLine[];
+    readonly sourceFilePath?: string;
+    readonly linesBeforeMatched: TextLine[];
+    readonly matchedLines: TextLine[];
+    readonly linesAfterMatched: TextLine[];
+    constructor(options: {
+        lines: TextLine[];
+        sourceFilePath?: string;
+    });
+    get startLine(): number;
+    get endLine(): number;
+    get numMatchedLines(): number;
+    toDisplayString(includeLineNumbers?: boolean): string;
+    static fromFileContents(options: {
+        fileContents: string;
+        line: number;
+        contextLinesBefore?: number;
+        contextLinesAfter?: number;
+        sourceFilePath?: string;
+    }): MatchedConsecutiveLines;
+}
+interface SearchTextOptions {
+    contextLinesBefore?: number;
+    contextLinesAfter?: number;
+}
+interface SearchFilesOptions extends SearchTextOptions {
+    rootPath?: string;
+    fileReader?: (absolutePath: string) => string;
+    pathsIncludeGlob?: string | null;
+    pathsExcludeGlob?: string | null;
+}
+export declare function searchFiles(relativeFilePaths: string[], pattern: string, options?: SearchFilesOptions): MatchedConsecutiveLines[];
+export {};