@reqlan/language 1.4.0

package/src/generated/module.ts

@@ -0,0 +1,38 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.3.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+import type { LangiumSharedCoreServices, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LanguageMetaData, Module } from 'langium';
+import { ReqlanAstReflection } from './ast.js';
+import { ReqlanGrammar, ReqlanCommentGrammar } from './grammar.js';
+
+export const ReqlanLanguageMetaData = {
+    languageId: 'reqlan',
+    fileExtensions: ['.rq'],
+    caseInsensitive: false,
+    mode: 'development'
+} as const satisfies LanguageMetaData;
+
+export const ReqlanCommentLanguageMetaData = {
+    languageId: 'reqlan-comment',
+    fileExtensions: [],
+    caseInsensitive: false,
+    mode: 'development'
+} as const satisfies LanguageMetaData;
+
+export const ReqlanGeneratedSharedModule: Module<LangiumSharedCoreServices, LangiumGeneratedSharedCoreServices> = {
+    AstReflection: () => new ReqlanAstReflection()
+};
+
+export const ReqlanGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
+    Grammar: () => ReqlanGrammar(),
+    LanguageMetaData: () => ReqlanLanguageMetaData,
+    parser: {}
+};
+
+export const ReqlanCommentGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
+    Grammar: () => ReqlanCommentGrammar(),
+    LanguageMetaData: () => ReqlanCommentLanguageMetaData,
+    parser: {}
+};

package/src/index.ts

@@ -0,0 +1,34 @@
+export * from './reqlan-module.js';
+export * from './reqlan-validator.js';
+export * from './reqlan-comment-resolver.js';
+export * from './reqlan-ignore-error.js';
+export * from './reqlan-file-references.js';
+export * from './reqlan-embedded-file-references.js';
+export * from './file-path-rewrite.js';
+export * from './reqlan-path-references.js';
+export * from './reqlan-path-resolve.js';
+export * from './reqlan-imports.js';
+export * from './reqlan-quoted-strings.js';
+export * from './reqlan-references.js';
+export * from './reqlan-reference-at-position.js';
+export * from './reqlan-attribute-catalog.js';
+export * from './reqlan-completion-context.js';
+export * from './reqlan-completion-provider.js';
+export * from './reqlan-path-completion.js';
+export * from './reqlan-code-action-provider.js';
+export * from './reqlan-idea-reference-site.js';
+export * from './reqlan-reference-search-site.js';
+export * from './reqlan-import-edits.js';
+export * from './reqlan-import-bindings.js';
+export * from './reqlan-namespace-import-links.js';
+export * from './reqlan-name-catalog.js';
+export * from './reqlan-workspace-attribute-catalog.js';
+export * from './reqlan-inlay-hint-settings.js';
+export * from './reqlan-code-lens-settings.js';
+export * from './reqlan-reference-code-lens.js';
+export { ReqlanInlayHintProvider } from './reqlan-inlay-hint-provider.js';
+export { ReqlanCodeLensProvider } from './reqlan-code-lens-provider.js';
+export { summarizeIdeaDeclaration, truncateSummary } from './reqlan-idea-summary.js';
+export * from './generated/ast.js';
+export * from './generated/grammar.js';
+export * from './generated/module.js';

package/src/reqlan-attribute-catalog.ts

@@ -0,0 +1,100 @@
+/**
+ * Endorsed attribute keys and workspace-wide attribute value catalog for completion.
+ */
+
+/** Common attributes from reqlan rq/language/syntax.rq attribute_forms. */
+export const ENDORSED_ATTRIBUTE_KEYS = [
+    'plan',
+    'status',
+    'priority',
+    'criticality',
+    'confirmation',
+    'owner',
+    'log',
+    'tags',
+    'references',
+    'refs',
+    'required',
+    'deprecated',
+    'tests'
+] as const;
+
+export interface AttributeCatalog {
+    keys: string[];
+    valuesByKey: Record<string, string[]>;
+}
+
+export class AttributeCatalogStore {
+    private catalog: AttributeCatalog = {
+        keys: [...ENDORSED_ATTRIBUTE_KEYS],
+        valuesByKey: {}
+    };
+
+    get(): AttributeCatalog {
+        return this.catalog;
+    }
+
+    update(catalog: AttributeCatalog): void {
+        this.catalog = mergeAttributeCatalogs(this.catalog, catalog);
+    }
+
+    reset(): void {
+        this.catalog = {
+            keys: [...ENDORSED_ATTRIBUTE_KEYS],
+            valuesByKey: {}
+        };
+    }
+
+    mergeWorkspaceKeys(keys: Iterable<string>, valuesByKey: Record<string, Iterable<string>>): void {
+        const mergedKeys = new Set<string>([...ENDORSED_ATTRIBUTE_KEYS, ...this.catalog.keys]);
+        for (const key of keys) {
+            mergedKeys.add(key);
+        }
+        const mergedValues: Record<string, string[]> = { ...this.catalog.valuesByKey };
+        for (const [key, values] of Object.entries(valuesByKey)) {
+            mergedKeys.add(key);
+            const existing = new Set(mergedValues[key] ?? []);
+            for (const value of values) {
+                if (value) {
+                    existing.add(value);
+                }
+            }
+            mergedValues[key] = [...existing].sort((left, right) => left.localeCompare(right));
+        }
+        this.catalog = {
+            keys: [...mergedKeys].sort((left, right) => left.localeCompare(right)),
+            valuesByKey: mergedValues
+        };
+    }
+}
+
+export const REQLAN_ATTRIBUTE_CATALOG_NOTIFICATION = 'reqlan/attributeCatalog';
+
+export const sharedAttributeCatalog = new AttributeCatalogStore();
+
+export function mergeAttributeCatalogs(...catalogs: AttributeCatalog[]): AttributeCatalog {
+    const keys = new Set<string>(ENDORSED_ATTRIBUTE_KEYS);
+    const valuesByKey = new Map<string, Set<string>>();
+    for (const catalog of catalogs) {
+        for (const key of catalog.keys) {
+            keys.add(key);
+        }
+        for (const [key, values] of Object.entries(catalog.valuesByKey)) {
+            keys.add(key);
+            if (!valuesByKey.has(key)) {
+                valuesByKey.set(key, new Set());
+            }
+            for (const value of values) {
+                if (value) {
+                    valuesByKey.get(key)!.add(value);
+                }
+            }
+        }
+    }
+    return {
+        keys: [...keys].sort((left, right) => left.localeCompare(right)),
+        valuesByKey: Object.fromEntries(
+            [...valuesByKey.entries()].map(([key, values]) => [key, [...values].sort()])
+        )
+    };
+}

package/src/reqlan-code-action-provider.ts

@@ -0,0 +1,385 @@
+/**
+ * Quick fixes for unresolved references: add import, rewrite qualified ref, search, create.
+ * Also offers a search code action when the cursor is inside a [reference] / [[wikilink]].
+ * rq:["../../../reqlan rq/extension/language-support/features-imports.rq".import_error]
+ * rq:["../../../reqlan rq/extension/features-commands.rq".search_code_actions]
+ */
+import type { LangiumDocument, URI } from 'langium';
+import { DocumentValidator, URI as UriCtor, UriUtils } from 'langium';
+import type { CodeActionParams, Command, Diagnostic } from 'vscode-languageserver';
+import { CodeActionKind } from 'vscode-languageserver';
+import type { CodeActionProvider } from 'langium/lsp';
+import {
+    isIdea,
+    isIdeaSet,
+    isModel,
+    isOneLinerIdea,
+    type Model
+} from './generated/ast.js';
+import {
+    buildFromImportEdit,
+    relativeRqImportPath
+} from './reqlan-import-edits.js';
+import type { ReqlanServices } from './reqlan-module.js';
+import {
+    sharedNameCatalog,
+    type NameCatalogEntry,
+    type NameCatalogKind
+} from './reqlan-name-catalog.js';
+import { findReferenceSearchSite, buildContextForRange } from './reqlan-reference-search-site.js';
+
+export const REQLAN_IMPORT_ERROR_SEARCH_COMMAND = 'reqlan.importError.search';
+export const REQLAN_IMPORT_ERROR_CREATE_COMMAND = 'reqlan.importError.createFile';
+export const REQLAN_SEARCH_REFERENCE_COMMAND = 'reqlan.searchReference';
+
+const MAX_IMPORT_SUGGESTIONS = 5;
+
+interface LinkingDiagnosticData {
+    code?: string;
+    containerType?: string;
+    property?: string;
+    refText?: string;
+}
+
+export interface ImportErrorCommandArgs {
+    documentUri: string;
+    refText: string;
+    range: Diagnostic['range'];
+}
+
+/** Args for reference search webview (replace existing ref or wrap prose). */
+export interface SearchReferenceCommandArgs {
+    documentUri: string;
+    refText: string;
+    range: Diagnostic['range'];
+    mode: 'replace' | 'wrap';
+    context?: {
+        ideaName: string;
+        before: string;
+        target: string;
+        after: string;
+    };
+}
+
+interface SymbolMatch {
+    name: string;
+    kind: NameCatalogKind;
+    fileUri: string;
+    importPath: string;
+}
+
+type CodeActionLike = import('vscode-languageserver').CodeAction;
+
+export class ReqlanCodeActionProvider implements CodeActionProvider {
+    private readonly documents: ReqlanServices['shared']['workspace']['LangiumDocuments'];
+    private readonly indexManager: ReqlanServices['shared']['workspace']['IndexManager'];
+
+    constructor(services: ReqlanServices) {
+        this.documents = services.shared.workspace.LangiumDocuments;
+        this.indexManager = services.shared.workspace.IndexManager;
+    }
+
+    getCodeActions(document: LangiumDocument, params: CodeActionParams): Array<Command | CodeActionLike> {
+        const actions: Array<Command | CodeActionLike> = [];
+        for (const diagnostic of params.context.diagnostics) {
+            actions.push(...this.actionsForDiagnostic(document, diagnostic));
+        }
+        const searchFromCursor = this.createSearchReferenceAction(document, params);
+        if (searchFromCursor) {
+            actions.push(searchFromCursor);
+        }
+        return actions;
+    }
+
+    /**
+     * When the cursor/selection is inside a [reference], or on prose that can
+     * become one, offer a search action that opens the idea-search webview.
+     */
+    private createSearchReferenceAction(
+        document: LangiumDocument,
+        params: CodeActionParams
+    ): CodeActionLike | undefined {
+        const site = findReferenceSearchSite(document, params.range);
+        if (!site) {
+            return undefined;
+        }
+        // Avoid duplicating the linking-error search action on the same range.
+        const alreadyHasSearch = site.mode === 'replace' && params.context.diagnostics.some(diagnostic => {
+            const data = diagnostic.data as LinkingDiagnosticData | undefined;
+            return data?.code === DocumentValidator.LinkingError
+                && data.refText === site.refText
+                && rangesOverlap(diagnostic.range, site.range);
+        });
+        if (alreadyHasSearch) {
+            return undefined;
+        }
+        const args: SearchReferenceCommandArgs = {
+            documentUri: document.textDocument.uri,
+            refText: site.refText,
+            range: site.range,
+            mode: site.mode,
+            context: site.context
+        };
+        const title = site.mode === 'wrap'
+            ? (site.refText
+                ? `Wrap '${site.refText}' as idea reference…`
+                : 'Wrap selection as idea reference…')
+            : (site.refText
+                ? `Search for idea to replace '${site.refText}'…`
+                : 'Search for idea reference…');
+        return {
+            title,
+            kind: CodeActionKind.Refactor,
+            command: {
+                title: 'Search for idea reference',
+                command: REQLAN_SEARCH_REFERENCE_COMMAND,
+                arguments: [args]
+            }
+        };
+    }
+
+    private actionsForDiagnostic(
+        document: LangiumDocument,
+        diagnostic: Diagnostic
+    ): Array<Command | CodeActionLike> {
+        const data = diagnostic.data as LinkingDiagnosticData | undefined;
+        if (data?.code !== DocumentValidator.LinkingError || !data.refText) {
+            return [];
+        }
+        if (!isResolvableIdeaProperty(data.property)) {
+            return [];
+        }
+
+        const refText = data.refText;
+        const actions: Array<Command | CodeActionLike> = [];
+        const matches = this.findMatches(document, refText);
+        let preferredSet = false;
+
+        for (const match of matches.slice(0, MAX_IMPORT_SUGGESTIONS)) {
+            if (match.kind === 'ideaset' || match.kind === 'file') {
+                continue;
+            }
+            const addImport = this.createAddImportAction(document, diagnostic, match, !preferredSet);
+            if (addImport) {
+                actions.push(addImport);
+                preferredSet = true;
+            }
+            const rewrite = this.createQualifiedRewriteAction(document, diagnostic, match);
+            if (rewrite) {
+                actions.push(rewrite);
+            }
+        }
+
+        actions.push(this.createSearchCommand(document, diagnostic, refText));
+        actions.push(this.createCreateFileCommand(document, diagnostic, refText));
+        return actions;
+    }
+
+    private findMatches(document: LangiumDocument, refText: string): SymbolMatch[] {
+        const byKey = new Map<string, SymbolMatch>();
+        const add = (match: SymbolMatch) => {
+            if (UriUtils.equals(UriCtor.parse(match.fileUri), document.uri)) {
+                return;
+            }
+            const key = `${match.kind}:${match.fileUri}:${match.name}`;
+            if (!byKey.has(key)) {
+                byKey.set(key, match);
+            }
+        };
+
+        for (const entry of sharedNameCatalog.findExact(refText)) {
+            add(this.toMatch(document.uri, entry));
+        }
+
+        for (const doc of this.documents.all) {
+            if (UriUtils.equals(doc.uri, document.uri)) {
+                continue;
+            }
+            const model = doc.parseResult.value;
+            if (!isModel(model)) {
+                continue;
+            }
+            for (const element of model.elements) {
+                if ((isIdea(element) || isOneLinerIdea(element) || isIdeaSet(element)) && element.name === refText) {
+                    add({
+                        name: element.name,
+                        kind: isIdeaSet(element) ? 'ideaset' : isOneLinerIdea(element) ? 'oneliner' : 'idea',
+                        fileUri: doc.uri.toString(),
+                        importPath: relativeRqImportPath(document.uri, doc.uri)
+                    });
+                }
+            }
+        }
+
+        for (const description of this.indexManager.allElements()) {
+            if (description.name !== refText || UriUtils.equals(description.documentUri, document.uri)) {
+                continue;
+            }
+            const kind = nodeTypeToKind(description.type);
+            if (!kind) {
+                continue;
+            }
+            add({
+                name: description.name,
+                kind,
+                fileUri: description.documentUri.toString(),
+                importPath: relativeRqImportPath(document.uri, description.documentUri)
+            });
+        }
+
+        return [...byKey.values()].sort((left, right) =>
+            left.importPath.length - right.importPath.length || left.name.localeCompare(right.name)
+        );
+    }
+
+    private toMatch(fromUri: URI, entry: NameCatalogEntry): SymbolMatch {
+        return {
+            name: entry.name,
+            kind: entry.kind,
+            fileUri: entry.fileUri,
+            importPath: relativeRqImportPath(fromUri, UriCtor.parse(entry.fileUri))
+        };
+    }
+
+    private createAddImportAction(
+        document: LangiumDocument,
+        diagnostic: Diagnostic,
+        match: SymbolMatch,
+        isPreferred: boolean
+    ): CodeActionLike | undefined {
+        const edit = buildFromImportEdit(document, match.importPath, match.name);
+        if (!edit) {
+            return undefined;
+        }
+        return {
+            title: `Add import from "${match.importPath}"`,
+            kind: CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            isPreferred,
+            edit: {
+                changes: {
+                    [document.textDocument.uri]: [edit]
+                }
+            }
+        };
+    }
+
+    private createQualifiedRewriteAction(
+        document: LangiumDocument,
+        diagnostic: Diagnostic,
+        match: SymbolMatch
+    ): CodeActionLike | undefined {
+        return {
+            title: `Change to ["${match.importPath}".${match.name}]`,
+            kind: CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            edit: {
+                changes: {
+                    [document.textDocument.uri]: [{
+                        range: diagnostic.range,
+                        newText: `"${match.importPath}".${match.name}`
+                    }]
+                }
+            }
+        };
+    }
+
+    private createSearchCommand(
+        document: LangiumDocument,
+        diagnostic: Diagnostic,
+        refText: string
+    ): CodeActionLike {
+        const args: SearchReferenceCommandArgs = {
+            documentUri: document.textDocument.uri,
+            refText,
+            range: diagnostic.range,
+            mode: 'replace',
+            context: buildContextForRange(document, diagnostic.range)
+        };
+        return {
+            title: `Search for idea to replace '${refText}'…`,
+            kind: CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            command: {
+                title: `Search for idea to replace '${refText}'`,
+                command: REQLAN_SEARCH_REFERENCE_COMMAND,
+                arguments: [args]
+            }
+        };
+    }
+
+    private createCreateFileCommand(
+        document: LangiumDocument,
+        diagnostic: Diagnostic,
+        refText: string
+    ): CodeActionLike {
+        const args: ImportErrorCommandArgs = {
+            documentUri: document.textDocument.uri,
+            refText,
+            range: diagnostic.range
+        };
+        return {
+            title: `Create '${refText}' in a new file and import it…`,
+            kind: CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            command: {
+                title: `Create '${refText}' in a new file`,
+                command: REQLAN_IMPORT_ERROR_CREATE_COMMAND,
+                arguments: [args]
+            }
+        };
+    }
+}
+
+function isResolvableIdeaProperty(property: string | undefined): boolean {
+    return property === 'idea' || property === 'ideaset' || property === 'members';
+}
+
+function rangesOverlap(
+    left: { start: { line: number; character: number }; end: { line: number; character: number } },
+    right: { start: { line: number; character: number }; end: { line: number; character: number } }
+): boolean {
+    if (left.end.line < right.start.line || right.end.line < left.start.line) {
+        return false;
+    }
+    if (left.end.line === right.start.line && left.end.character < right.start.character) {
+        return false;
+    }
+    if (right.end.line === left.start.line && right.end.character < left.start.character) {
+        return false;
+    }
+    return true;
+}
+
+function nodeTypeToKind(type: string): NameCatalogKind | undefined {
+    switch (type) {
+        case 'Idea':
+            return 'idea';
+        case 'OneLinerIdea':
+            return 'oneliner';
+        case 'IdeaSet':
+            return 'ideaset';
+        default:
+            return undefined;
+    }
+}
+
+/** Test helper: collect quick fixes for linking diagnostics on a document. */
+export function collectImportErrorCodeActions(
+    provider: ReqlanCodeActionProvider,
+    document: LangiumDocument
+): Array<Command | CodeActionLike> {
+    const diagnostics = (document.diagnostics ?? []).filter(diagnostic => {
+        const data = diagnostic.data as LinkingDiagnosticData | undefined;
+        return data?.code === DocumentValidator.LinkingError;
+    });
+    return provider.getCodeActions(document, {
+        textDocument: { uri: document.textDocument.uri },
+        range: diagnostics[0]?.range ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+        context: { diagnostics }
+    });
+}
+
+export function isModelDocument(document: LangiumDocument): document is LangiumDocument<Model> {
+    return isModel(document.parseResult.value);
+}

package/src/reqlan-code-lens-provider.ts

@@ -0,0 +1,54 @@
+/**
+ * CodeLens buttons classifying references (idea, reqlan/other file, folder).
+ */
+import type { LangiumDocument } from 'langium';
+import { AstUtils } from 'langium';
+import type { CodeLensProvider } from 'langium/lsp';
+import type { CancellationToken } from 'vscode-languageserver';
+import type { CodeLens, CodeLensParams } from 'vscode-languageserver';
+import {
+    REQLAN_REFERENCE_CODE_LENS_SETTING,
+    referenceCodeLensEnabled,
+    type ReferenceCodeLensSettings
+} from './reqlan-code-lens-settings.js';
+import {
+    buildReferenceCodeLens,
+    classifyReferenceForCodeLens
+} from './reqlan-reference-code-lens.js';
+import type { ReqlanServices } from './reqlan-module.js';
+
+export class ReqlanCodeLensProvider implements CodeLensProvider {
+
+    private readonly services: ReqlanServices;
+
+    constructor(services: ReqlanServices) {
+        this.services = services;
+    }
+
+    async provideCodeLens(
+        document: LangiumDocument,
+        _params: CodeLensParams,
+        _cancelToken?: CancellationToken
+    ): Promise<CodeLens[] | undefined> {
+        const settings = await this.services.shared.workspace.ConfigurationProvider.getConfiguration(
+            'reqlan',
+            REQLAN_REFERENCE_CODE_LENS_SETTING
+        ) as ReferenceCodeLensSettings | undefined;
+        if (!referenceCodeLensEnabled(settings)) {
+            return [];
+        }
+
+        const lenses: CodeLens[] = [];
+        for (const node of AstUtils.streamAst(document.parseResult.value)) {
+            const classification = classifyReferenceForCodeLens(this.services, node);
+            if (!classification) {
+                continue;
+            }
+            const lens = buildReferenceCodeLens(this.services, node, classification);
+            if (lens) {
+                lenses.push(lens);
+            }
+        }
+        return lenses;
+    }
+}

package/src/reqlan-code-lens-settings.ts

@@ -0,0 +1,42 @@
+/**
+ * Workspace settings for reference CodeLens classification buttons.
+ */
+export const REQLAN_REFERENCE_CODE_LENS_SETTING = 'referencesCodeLens';
+
+/** VS Code command invoked when clicking a reference classification CodeLens. */
+export const REQLAN_OPEN_REFERENCE_CODE_LENS_COMMAND = 'reqlan.openReferenceCodeLens';
+
+/** VS Code command palette toggle for reference CodeLens. */
+export const REQLAN_TOGGLE_REFERENCE_CODE_LENS_COMMAND = 'reqlan.toggleReferenceCodeLens';
+
+export interface ReferenceCodeLensSettings {
+    enabled?: boolean;
+}
+
+export function referenceCodeLensEnabled(settings: ReferenceCodeLensSettings | undefined): boolean {
+    return settings?.enabled === true;
+}
+
+export type ReferenceCodeLensKind = 'idea' | 'reqlan-file' | 'file' | 'folder';
+
+/**
+ * Payload for the CodeLens click handler. Opens a reference card (not direct navigation —
+ * references already act as editor links).
+ */
+export interface ReferenceCodeLensPayload {
+    kind: ReferenceCodeLensKind;
+    /** Classification label, e.g. `open idea` / `open ts file`. */
+    classification: string;
+    /** Short target name shown on the card. */
+    displayName: string;
+    targetUri: string;
+    line?: number;
+    character?: number;
+    folderFiles?: string[];
+    /** File extension without leading dot, used for `open {extension} file` labels. */
+    extension?: string;
+    /** Idea body / path summary for the card. */
+    summary?: string;
+    /** Stats lines shown on the card (referencers, last edited, etc.). */
+    stats: string[];
+}