@nowline/lsp 0.4.1

package/src/providers/completion.ts

@@ -0,0 +1,202 @@
+import type { MaybePromise } from 'langium';
+import {
+    type CompletionAcceptor,
+    type CompletionContext,
+    DefaultCompletionProvider,
+    type NextFeature,
+} from 'langium/lsp';
+import { type CompletionItem, CompletionItemKind } from 'vscode-languageserver';
+import type { NowlineLspServices } from '../nowline-lsp-module.js';
+import {
+    BUILTIN_CAPACITY_ICONS,
+    BUILTIN_ICON_NAMES,
+    BUILTIN_STATUSES,
+    collectNamedEntities,
+    entityKind,
+    fileFromDocument,
+    type NamedEntity,
+    REFERENCE_PROP_KEYS,
+} from '../references/ast-utils.js';
+
+/**
+ * Per-key allowlist of entity kinds that make sense as values. Keeps
+ * suggestions focused — typing `style:` only shows styles instead of every
+ * declared id in the file.
+ *
+ * The string values match the output of `entityKind()`
+ * (`StyleDeclaration` → `style`, `ItemDeclaration` → `item`, …).
+ */
+const REF_KEY_TO_KINDS: Record<string, ReadonlySet<string>> = {
+    after: new Set(['item', 'milestone', 'anchor', 'parallel', 'group']),
+    before: new Set(['item', 'milestone', 'anchor', 'parallel', 'group']),
+    depends: new Set(['item', 'milestone', 'anchor', 'parallel', 'group']),
+    on: new Set(['item', 'swimlane', 'parallel', 'group', 'milestone']),
+    owner: new Set(['person', 'team']),
+    team: new Set(['team']),
+    style: new Set(['style']),
+    size: new Set(['size']),
+    status: new Set(['status']),
+    labels: new Set(['label']),
+    icon: new Set(['symbol']),
+    'capacity-icon': new Set(['symbol']),
+};
+
+/**
+ * Custom completion provider. Defers to Langium's keyword + property-key
+ * completion (free from the grammar) and adds:
+ *
+ *  - Id-reference completion when the cursor sits in a reference property's
+ *    value position (`after:`, `before:`, `style:`, `size:`, `labels:[...]`,
+ *    etc.). Each key only suggests entities whose kind makes sense for it
+ *    (see `REF_KEY_TO_KINDS`).
+ *  - Status-value completion: built-in values plus custom `status`
+ *    declarations.
+ *  - Icon / capacity-icon built-in vocabulary plus user-declared symbols.
+ */
+export class NowlineCompletionProvider extends DefaultCompletionProvider {
+    constructor(services: NowlineLspServices) {
+        super(services);
+    }
+
+    protected override completionFor(
+        context: CompletionContext,
+        next: NextFeature,
+        acceptor: CompletionAcceptor,
+    ): MaybePromise<void> {
+        const valueHint = detectPropertyValueContext(context);
+        if (valueHint) {
+            this.acceptValueCompletions(context, valueHint, acceptor);
+        }
+        return super.completionFor(context, next, acceptor);
+    }
+
+    /**
+     * Public so subclasses (and tests) can extend the value-completion table
+     * without rewriting the dispatch logic.
+     */
+    protected acceptValueCompletions(
+        context: CompletionContext,
+        hint: PropertyValueContext,
+        acceptor: CompletionAcceptor,
+    ): void {
+        const file = fileFromDocument(context.document);
+        if (!file) return;
+
+        if (hint.key === 'status') {
+            for (const status of BUILTIN_STATUSES) {
+                acceptor(context, {
+                    label: status,
+                    kind: CompletionItemKind.EnumMember,
+                    detail: 'built-in status',
+                    insertText: status,
+                });
+            }
+        }
+        if (hint.key === 'icon') {
+            for (const icon of BUILTIN_ICON_NAMES) {
+                acceptor(context, {
+                    label: icon,
+                    kind: CompletionItemKind.EnumMember,
+                    detail: 'built-in icon',
+                    insertText: icon,
+                });
+            }
+        }
+        if (hint.key === 'capacity-icon') {
+            for (const icon of BUILTIN_CAPACITY_ICONS) {
+                acceptor(context, {
+                    label: icon,
+                    kind: CompletionItemKind.EnumMember,
+                    detail: 'built-in capacity icon',
+                    insertText: icon,
+                });
+            }
+        }
+
+        if (REFERENCE_PROP_KEYS.has(hint.key)) {
+            const allowed = REF_KEY_TO_KINDS[hint.key];
+            for (const ent of collectNamedEntities(file)) {
+                if (!ent.name) continue;
+                if (allowed && !allowed.has(entityKind(ent))) continue;
+                acceptor(context, buildEntityItem(ent));
+            }
+        }
+    }
+}
+
+export interface PropertyValueContext {
+    key: string;
+}
+
+/**
+ * Best-effort detection of "we're typing inside a property value".
+ *
+ * The grammar tokenises `key:` as a single PROPERTY_KEY_WITH_COLON, so we
+ * walk the text backwards from the cursor over identifier characters, list
+ * separators, and `[` to find the closest `key:` token. If we hit `\n` or any
+ * other terminator before finding one, the cursor isn't inside a property
+ * value.
+ *
+ * Returns the property key (without the trailing colon) when a match is
+ * found.
+ */
+function detectPropertyValueContext(context: CompletionContext): PropertyValueContext | undefined {
+    const text = context.textDocument.getText();
+    let i = context.tokenOffset - 1;
+    while (i >= 0) {
+        const ch = text[i];
+        if (ch === ':') break;
+        if (ch === '\n' || ch === '\r') return undefined;
+        if (!/[A-Za-z0-9_\-,. \t[\]"'%/]/.test(ch)) return undefined;
+        i--;
+    }
+    if (i < 0) return undefined;
+    let j = i - 1;
+    while (j >= 0 && /[A-Za-z0-9_-]/.test(text[j])) j--;
+    const key = text.slice(j + 1, i);
+    if (!key) return undefined;
+    return { key };
+}
+
+function buildEntityItem(entity: NamedEntity): CompletionItem {
+    const kind = entityKind(entity);
+    return {
+        label: entity.name!,
+        kind: kindFor(kind),
+        detail: entity.title ? `${kind} — ${entity.title}` : kind,
+        insertText: entity.name!,
+    };
+}
+
+function kindFor(kind: string): CompletionItemKind {
+    switch (kind) {
+        case 'item':
+            return CompletionItemKind.Field;
+        case 'swimlane':
+            return CompletionItemKind.Class;
+        case 'parallel':
+        case 'group':
+            return CompletionItemKind.Module;
+        case 'anchor':
+        case 'milestone':
+            return CompletionItemKind.Event;
+        case 'person':
+            return CompletionItemKind.Constant;
+        case 'team':
+            return CompletionItemKind.Module;
+        case 'label':
+            return CompletionItemKind.EnumMember;
+        case 'size':
+            return CompletionItemKind.Value;
+        case 'status':
+            return CompletionItemKind.Enum;
+        case 'style':
+            return CompletionItemKind.Color;
+        case 'symbol':
+            return CompletionItemKind.Snippet;
+        case 'footnote':
+            return CompletionItemKind.Text;
+        default:
+            return CompletionItemKind.Reference;
+    }
+}

package/src/providers/definition.ts

@@ -0,0 +1,58 @@
+import type { LangiumDocument, MaybePromise } from 'langium';
+import type { DefinitionProvider } from 'langium/lsp';
+import type { CancellationToken, DefinitionParams } from 'vscode-languageserver';
+import { LocationLink } from 'vscode-languageserver';
+import type { NowlineLspServices } from '../nowline-lsp-module.js';
+import {
+    buildEntityIndex,
+    fileFromDocument,
+    leafAt,
+    nameRangeOf,
+    propertyValueAt,
+    propKey,
+    REFERENCE_PROP_KEYS,
+} from '../references/ast-utils.js';
+
+/**
+ * Custom definition provider. The Nowline grammar uses `PropertyAtom` (plain
+ * text) for cross-references, so Langium's default cross-ref-aware provider
+ * has nothing to follow. We walk the AST instead: when the cursor sits on a
+ * value of a reference property (`after:`, `before:`, `owner:`, `on:`,
+ * `depends:[]`), look up the target id in the file-level entity index and
+ * return its declaration site.
+ */
+export class NowlineDefinitionProvider implements DefinitionProvider {
+    constructor(_services: NowlineLspServices) {
+        /* No collaborator dependencies; AST helpers are pure. */
+    }
+
+    getDefinition(
+        document: LangiumDocument,
+        params: DefinitionParams,
+        _cancelToken?: CancellationToken,
+    ): MaybePromise<LocationLink[] | undefined> {
+        const file = fileFromDocument(document);
+        if (!file) return undefined;
+        const offset = document.textDocument.offsetAt(params.position);
+        const leaf = leafAt(document, offset);
+        const hit = propertyValueAt(leaf);
+        if (!hit) return undefined;
+        if (!REFERENCE_PROP_KEYS.has(propKey(hit.prop))) return undefined;
+
+        const index = buildEntityIndex(file);
+        const target = index.get(hit.value);
+        if (!target) return undefined;
+        const targetCst = target.$cstNode;
+        if (!targetCst) return undefined;
+
+        const nameRange = nameRangeOf(target) ?? targetCst.range;
+        return [
+            LocationLink.create(
+                document.uri.toString(),
+                targetCst.range,
+                nameRange,
+                hit.valueNode.range,
+            ),
+        ];
+    }
+}

package/src/providers/document-symbols.ts

@@ -0,0 +1,152 @@
+import {
+    type GroupBlock,
+    type ItemDeclaration,
+    isAnchorDeclaration,
+    isFootnoteDeclaration,
+    isGroupBlock,
+    isItemDeclaration,
+    isLabelDeclaration,
+    isMilestoneDeclaration,
+    isParallelBlock,
+    isPersonDeclaration,
+    isSizeDeclaration,
+    isStatusDeclaration,
+    isSwimlaneDeclaration,
+    isTeamDeclaration,
+    type ParallelBlock,
+    type RoadmapDeclaration,
+    type SwimlaneContent,
+    type SwimlaneDeclaration,
+} from '@nowline/core';
+import type { AstNode, LangiumDocument, MaybePromise } from 'langium';
+import type { DocumentSymbolProvider } from 'langium/lsp';
+import type {
+    CancellationToken,
+    DocumentSymbol,
+    DocumentSymbolParams,
+    Range,
+} from 'vscode-languageserver';
+import { SymbolKind } from 'vscode-languageserver';
+import type { NowlineLspServices } from '../nowline-lsp-module.js';
+import { entityKind, fileFromDocument, nameRangeOf } from '../references/ast-utils.js';
+
+/**
+ * Outline view: roadmap → swimlanes → items, with parallel/group nesting and
+ * top-level anchors / milestones / footnotes / people / teams / labels /
+ * sizes / statuses surfaced as siblings of the swimlanes. Mirrors the layout
+ * engine's traversal so what authors see in the outline matches what gets
+ * rendered.
+ */
+export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
+    constructor(_services: NowlineLspServices) {
+        /* AST helpers are pure. */
+    }
+
+    getSymbols(
+        document: LangiumDocument,
+        _params: DocumentSymbolParams,
+        _cancelToken?: CancellationToken,
+    ): MaybePromise<DocumentSymbol[]> {
+        const file = fileFromDocument(document);
+        if (!file) return [];
+
+        const symbols: DocumentSymbol[] = [];
+        if (file.roadmapDecl) {
+            const roadmapSymbol = this.roadmapSymbol(file.roadmapDecl);
+            for (const entry of file.roadmapEntries) {
+                const child = this.entrySymbol(entry);
+                if (child) roadmapSymbol.children!.push(child);
+            }
+            symbols.push(roadmapSymbol);
+        } else {
+            for (const entry of file.roadmapEntries) {
+                const child = this.entrySymbol(entry);
+                if (child) symbols.push(child);
+            }
+        }
+        return symbols;
+    }
+
+    private roadmapSymbol(roadmap: RoadmapDeclaration): DocumentSymbol {
+        const range = roadmap.$cstNode!.range;
+        const nameRange = nameRangeOf(roadmap) ?? range;
+        return {
+            name: roadmap.name ?? roadmap.title ?? 'roadmap',
+            detail: roadmap.title && roadmap.name ? roadmap.title : 'roadmap',
+            kind: SymbolKind.Package,
+            range,
+            selectionRange: nameRange,
+            children: [],
+        };
+    }
+
+    private entrySymbol(entry: AstNode): DocumentSymbol | undefined {
+        if (isSwimlaneDeclaration(entry)) return this.swimlaneSymbol(entry);
+        if (isAnchorDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Event);
+        if (isMilestoneDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Event);
+        if (isFootnoteDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.String);
+        if (isPersonDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Constant);
+        if (isTeamDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Module);
+        if (isLabelDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.EnumMember);
+        if (isSizeDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Number);
+        if (isStatusDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Enum);
+        return undefined;
+    }
+
+    private swimlaneSymbol(lane: SwimlaneDeclaration): DocumentSymbol {
+        const sym = this.simpleSymbol(lane, SymbolKind.Namespace, true);
+        for (const child of lane.content) {
+            const sub = this.trackChildSymbol(child);
+            if (sub) sym.children!.push(sub);
+        }
+        return sym;
+    }
+
+    private trackChildSymbol(child: SwimlaneContent): DocumentSymbol | undefined {
+        if (isItemDeclaration(child)) return this.itemSymbol(child);
+        if (isParallelBlock(child)) return this.parallelSymbol(child);
+        if (isGroupBlock(child)) return this.groupSymbol(child);
+        return undefined;
+    }
+
+    private itemSymbol(item: ItemDeclaration): DocumentSymbol {
+        return this.simpleSymbol(item, SymbolKind.Field);
+    }
+
+    private parallelSymbol(node: ParallelBlock): DocumentSymbol {
+        const sym = this.simpleSymbol(node, SymbolKind.Array, true);
+        for (const child of node.content) {
+            const sub = this.trackChildSymbol(child);
+            if (sub) sym.children!.push(sub);
+        }
+        return sym;
+    }
+
+    private groupSymbol(node: GroupBlock): DocumentSymbol {
+        const sym = this.simpleSymbol(node, SymbolKind.Object, true);
+        for (const child of node.content) {
+            const sub = this.trackChildSymbol(child);
+            if (sub) sym.children!.push(sub);
+        }
+        return sym;
+    }
+
+    private simpleSymbol(
+        entity: AstNode & { name?: string; title?: string },
+        kind: SymbolKind,
+        withChildrenSlot = false,
+    ): DocumentSymbol {
+        const range: Range = entity.$cstNode!.range;
+        const name = entity.name ?? entity.title ?? entityKind(entity);
+        const detail = entity.title && entity.name ? entity.title : entityKind(entity);
+        const symbol: DocumentSymbol = {
+            name,
+            detail,
+            kind,
+            range,
+            selectionRange: nameRangeOf(entity) ?? range,
+        };
+        if (withChildrenSlot) symbol.children = [];
+        return symbol;
+    }
+}

package/src/providers/hover.ts

@@ -0,0 +1,98 @@
+import type { LangiumDocument, MaybePromise } from 'langium';
+import type { HoverProvider } from 'langium/lsp';
+import type { CancellationToken, Hover, HoverParams, Range } from 'vscode-languageserver';
+import { MarkupKind } from 'vscode-languageserver';
+import type { NowlineLspServices } from '../nowline-lsp-module.js';
+import {
+    buildEntityIndex,
+    declarationAt,
+    entityKind,
+    fileFromDocument,
+    leafAt,
+    type NamedEntity,
+    propertyValueAt,
+    propKey,
+    REFERENCE_PROP_KEYS,
+} from '../references/ast-utils.js';
+
+/**
+ * Hover provider. Surfaces the resolved entity (kind + id + title), plus the
+ * subset of properties most authors care about while editing — status, owner,
+ * link, date, duration / size — when the cursor sits on either:
+ *
+ *  - The `name=ID` token of an entity declaration.
+ *  - The value of a reference property (`after:`, `before:`, `owner:`, etc.).
+ */
+export class NowlineHoverProvider implements HoverProvider {
+    constructor(_services: NowlineLspServices) {
+        /* AST helpers are pure. */
+    }
+
+    getHoverContent(
+        document: LangiumDocument,
+        params: HoverParams,
+        _cancelToken?: CancellationToken,
+    ): MaybePromise<Hover | undefined> {
+        const file = fileFromDocument(document);
+        if (!file) return undefined;
+        const offset = document.textDocument.offsetAt(params.position);
+        const leaf = leafAt(document, offset);
+        if (!leaf) return undefined;
+
+        const decl = declarationAt(leaf);
+        if (decl) return this.hoverFor(decl, leaf.range);
+
+        const propHit = propertyValueAt(leaf);
+        if (propHit && REFERENCE_PROP_KEYS.has(propKey(propHit.prop))) {
+            const target = buildEntityIndex(file).get(propHit.value);
+            if (!target) return undefined;
+            return this.hoverFor(target, leaf.range);
+        }
+
+        return undefined;
+    }
+
+    private hoverFor(entity: NamedEntity, range: Range): Hover {
+        const kind = entityKind(entity);
+        const id = entity.name ?? '';
+        const title = entity.title;
+
+        const lines: string[] = [];
+        const header = id ? `**${kind} \`${id}\`**` : `**${kind}**`;
+        lines.push(header);
+        if (title) lines.push(`_${title}_`);
+
+        const props =
+            (entity as { properties?: { key: string; value?: string; values?: string[] }[] })
+                .properties ?? [];
+        const surfaced = [
+            'status',
+            'owner',
+            'link',
+            'date',
+            'duration',
+            'size',
+            'effort',
+            'capacity',
+        ];
+        const rendered: string[] = [];
+        for (const key of surfaced) {
+            const prop = props.find((p) => propKey(p as { key: string }) === key);
+            if (!prop) continue;
+            const value = prop.value ?? prop.values?.join(', ');
+            if (value) rendered.push(`- \`${key}:\` ${value}`);
+        }
+        if (rendered.length) {
+            lines.push('');
+            lines.push(...rendered);
+        }
+
+        return {
+            range,
+            contents: {
+                kind: MarkupKind.Markdown,
+                value: lines.join('\n'),
+            },
+        };
+    }
+}

package/src/providers/references.ts

@@ -0,0 +1,86 @@
+import type { CstNode, LangiumDocument, MaybePromise } from 'langium';
+import { CstUtils } from 'langium';
+import type { ReferencesProvider } from 'langium/lsp';
+import type { CancellationToken, ReferenceParams } from 'vscode-languageserver';
+import { Location } from 'vscode-languageserver';
+import type { NowlineLspServices } from '../nowline-lsp-module.js';
+import {
+    declarationAt,
+    fileFromDocument,
+    findDeclarationRange,
+    leafAt,
+    propertyValueAt,
+    propKey,
+    REFERENCE_PROP_KEYS,
+    visitAllProperties,
+} from '../references/ast-utils.js';
+
+/**
+ * Custom find-references provider. Resolves the symbol the cursor is on to a
+ * target id (either the declared name itself or the value the cursor sits on
+ * inside a reference property), then walks the file collecting every
+ * text-matching usage in known reference-property positions.
+ *
+ * Honours `params.context.includeDeclaration`: when true, the declaration
+ * site is included in the result list.
+ */
+export class NowlineReferencesProvider implements ReferencesProvider {
+    constructor(_services: NowlineLspServices) {
+        /* AST helpers are pure. */
+    }
+
+    findReferences(
+        document: LangiumDocument,
+        params: ReferenceParams,
+        _cancelToken?: CancellationToken,
+    ): MaybePromise<Location[]> {
+        const file = fileFromDocument(document);
+        if (!file) return [];
+        const offset = document.textDocument.offsetAt(params.position);
+        const leaf = leafAt(document, offset);
+        if (!leaf) return [];
+
+        const targetId = resolveTargetId(leaf);
+        if (!targetId) return [];
+
+        const locations: Location[] = [];
+        const uri = document.uri.toString();
+
+        if (params.context.includeDeclaration) {
+            const declRange = findDeclarationRange(file, targetId);
+            if (declRange) locations.push(Location.create(uri, declRange));
+        }
+
+        visitAllProperties(file, (prop) => {
+            if (!REFERENCE_PROP_KEYS.has(propKey(prop))) return;
+            for (const leafNode of valueLeavesOf(prop.$cstNode)) {
+                if (leafNode.text === targetId) {
+                    locations.push(Location.create(uri, leafNode.range));
+                }
+            }
+        });
+
+        return locations;
+    }
+}
+
+function resolveTargetId(leaf: CstNode): string | undefined {
+    const decl = declarationAt(leaf);
+    if (decl?.name) return decl.name;
+    const propHit = propertyValueAt(leaf);
+    if (propHit && REFERENCE_PROP_KEYS.has(propKey(propHit.prop))) {
+        return propHit.value;
+    }
+    return undefined;
+}
+
+function* valueLeavesOf(cst: CstNode | undefined): IterableIterator<CstNode> {
+    if (!cst) return;
+    for (const leaf of CstUtils.flattenCst(cst)) {
+        if (leaf.hidden) continue;
+        // Skip the property key (`after:` / `owner:` / …) so it doesn't
+        // surface as a self-reference.
+        if (leaf.text.endsWith(':')) continue;
+        yield leaf;
+    }
+}