@nowline/lsp 0.8.5 → 0.9.0

package/src/providers/definition.ts

@@ -18,7 +18,7 @@ import {
  * 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
+ * `labels:[]`, ...), look up the target id in the file-level entity index and
  * return its declaration site.
  */
 export class NowlineDefinitionProvider implements DefinitionProvider {

package/src/providers/document-symbols.ts

@@ -13,11 +13,13 @@ import {
     isStatusDeclaration,
     isSwimlaneDeclaration,
     isTeamDeclaration,
+    isWaveDeclaration,
     type ParallelBlock,
     type RoadmapDeclaration,
-    type SwimlaneContent,
     type SwimlaneDeclaration,
+    singleLine,
 } from '@nowline/core';
+import { type TrackNode, trackChildren } from '@nowline/core/internal';
 import type { AstNode, LangiumDocument, MaybePromise } from 'langium';
 import type { DocumentSymbolProvider } from 'langium/lsp';
 import type {
@@ -30,10 +32,20 @@ import { SymbolKind } from '../lsp-protocol.js';
 import type { NowlineLspServices } from '../nowline-lsp-module.js';
 import { entityKind, fileFromDocument, nameRangeOf } from '../references/ast-utils.js';
 
+/**
+ * An outline entry is one line of text, but a quoted title can carry
+ * explicit line breaks (`"Technology\nSelection"`), so each break is shown
+ * as a single space. `undefined` stays `undefined` so callers can fall back
+ * (as they must for a title that was only line breaks, which collapses to '').
+ */
+function singleLineTitle(title: string | undefined): string | undefined {
+    return title === undefined ? undefined : singleLine(title);
+}
+
 /**
  * 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
+ * sizes / statuses / waves surfaced as siblings of the swimlanes. Mirrors the layout
  * engine's traversal so what authors see in the outline matches what gets
  * rendered.
  */
@@ -71,8 +83,8 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
         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',
+            name: roadmap.name ?? (singleLineTitle(roadmap.title) || 'roadmap'),
+            detail: roadmap.title && roadmap.name ? singleLine(roadmap.title) : 'roadmap',
             kind: SymbolKind.Package,
             range,
             selectionRange: nameRange,
@@ -90,19 +102,15 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
         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);
+        if (isWaveDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Struct);
         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;
+        return this.withTrackChildren(this.simpleSymbol(lane, SymbolKind.Namespace, true), lane);
     }
 
-    private trackChildSymbol(child: SwimlaneContent): DocumentSymbol | undefined {
+    private trackChildSymbol(child: TrackNode): DocumentSymbol | undefined {
         if (isItemDeclaration(child)) return this.itemSymbol(child);
         if (isParallelBlock(child)) return this.parallelSymbol(child);
         if (isGroupBlock(child)) return this.groupSymbol(child);
@@ -114,17 +122,19 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
     }
 
     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;
+        return this.withTrackChildren(this.simpleSymbol(node, SymbolKind.Array, true), node);
     }
 
     private groupSymbol(node: GroupBlock): DocumentSymbol {
-        const sym = this.simpleSymbol(node, SymbolKind.Object, true);
-        for (const child of node.content) {
+        return this.withTrackChildren(this.simpleSymbol(node, SymbolKind.Object, true), node);
+    }
+
+    // The container's track children (descriptions skipped) as nested symbols.
+    private withTrackChildren(
+        sym: DocumentSymbol,
+        container: SwimlaneDeclaration | GroupBlock | ParallelBlock,
+    ): DocumentSymbol {
+        for (const child of trackChildren(container)) {
             const sub = this.trackChildSymbol(child);
             if (sub) sym.children!.push(sub);
         }
@@ -137,8 +147,8 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
         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 name = entity.name ?? (singleLineTitle(entity.title) || entityKind(entity));
+        const detail = entity.title && entity.name ? singleLine(entity.title) : entityKind(entity);
         const symbol: DocumentSymbol = {
             name,
             detail,

package/src/providers/hover.ts

@@ -1,4 +1,21 @@
-import type { LangiumDocument, MaybePromise } from 'langium';
+import {
+    assignWaves,
+    isGroupBlock,
+    isItemDeclaration,
+    isNonWorkingDeclaration,
+    isParallelBlock,
+    isSwimlaneDeclaration,
+    isWaveDeclaration,
+    isWorkingDeclaration,
+    type NowlineFile,
+    ownWaves,
+    singleLine,
+    type WaveAssignment,
+    type WaveDeclaration,
+    waveIndexMap,
+} from '@nowline/core';
+import { classifyCalendarDeclaration } from '@nowline/core/internal';
+import type { AstNode, LangiumDocument, MaybePromise } from 'langium';
 import type { HoverProvider } from 'langium/lsp';
 import type { CancellationToken, Hover, HoverParams, Range } from '../lsp-protocol.js';
 import { MarkupKind } from '../lsp-protocol.js';
@@ -8,6 +25,7 @@ import {
     declarationAt,
     entityKind,
     fileFromDocument,
+    isCalendarDeclaration,
     leafAt,
     type NamedEntity,
     propertyValueAt,
@@ -22,6 +40,15 @@ import {
  *
  *  - The `name=ID` token of an entity declaration.
  *  - The value of a reference property (`after:`, `before:`, `owner:`, etc.).
+ *
+ * Waves (specs/waves.md): a wave shows its position (`wave k of n`), title,
+ * description and member count; an item in a roadmap with waves shows its
+ * effective wave, or `background (no wave)`. Waves come from the file's own
+ * declarations only — the LSP does not resolve includes.
+ *
+ * Calendar declarations (`non-working`, `working`, specs/working-calendar.md):
+ * the declaration shows its id, title, and `date`, `every`, `start` and `end`,
+ * plus a note when its title is never drawn on the chart (§7.4).
  */
 export class NowlineHoverProvider implements HoverProvider {
     constructor(_services: NowlineLspServices) {
@@ -40,19 +67,19 @@ export class NowlineHoverProvider implements HoverProvider {
         if (!leaf) return undefined;
 
         const decl = declarationAt(leaf);
-        if (decl) return this.hoverFor(decl, leaf.range);
+        if (decl) return this.hoverFor(file, 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 this.hoverFor(file, target, leaf.range);
         }
 
         return undefined;
     }
 
-    private hoverFor(entity: NamedEntity, range: Range): Hover {
+    private hoverFor(file: NowlineFile, entity: NamedEntity, range: Range): Hover {
         const kind = entityKind(entity);
         const id = entity.name ?? '';
         const title = entity.title;
@@ -61,20 +88,14 @@ export class NowlineHoverProvider implements HoverProvider {
         const header = id ? `**${kind} \`${id}\`**` : `**${kind}**`;
         lines.push(header);
         if (title) lines.push(`_${title}_`);
+        // Own paragraph so Markdown does not fold the wave lines into the title.
+        const waveInfo = waveLines(file, entity);
+        if (waveInfo.length) lines.push('', ...waveInfo);
 
         const props =
             (entity as { properties?: { key: string; value?: string; values?: string[] }[] })
                 .properties ?? [];
-        const surfaced = [
-            'status',
-            'owner',
-            'link',
-            'date',
-            'duration',
-            'size',
-            'effort',
-            'capacity',
-        ];
+        const surfaced = isCalendarDeclaration(entity) ? CALENDAR_SURFACED : ITEM_SURFACED;
         const rendered: string[] = [];
         for (const key of surfaced) {
             const prop = props.find((p) => propKey(p as { key: string }) === key);
@@ -86,6 +107,8 @@ export class NowlineHoverProvider implements HoverProvider {
             lines.push('');
             lines.push(...rendered);
         }
+        const note = undrawnTitleNote(entity);
+        if (note) lines.push('', `_${note}_`);
 
         return {
             range,
@@ -96,3 +119,90 @@ export class NowlineHoverProvider implements HoverProvider {
         };
     }
 }
+
+const ITEM_SURFACED = ['status', 'owner', 'link', 'date', 'duration', 'size', 'effort', 'capacity'];
+
+// A `non-working` / `working` declaration is described by its days, not by an
+// item's status or duration (specs/working-calendar.md §4.1).
+const CALENDAR_SURFACED = ['date', 'every', 'start', 'end'];
+
+/**
+ * Why a calendar declaration's title is never drawn, or undefined when it is
+ * drawn, there is no title, or the shape is malformed (NW1, §4.1; core's
+ * `classifyCalendarDeclaration` reads the shape). Dated,
+ * titled declarations are labelled, `non-working` or `working`; a titled
+ * bounded recurrence is not (specs/working-calendar.md §7.4 "Which rules are
+ * labelled"). The open-ended week is the baseline and gets no note.
+ */
+function undrawnTitleNote(entity: NamedEntity): string | undefined {
+    if (!isNonWorkingDeclaration(entity) && !isWorkingDeclaration(entity)) return undefined;
+    if (!entity.title) return undefined;
+    const { shape } = classifyCalendarDeclaration(entity);
+    if (shape === 'half-bounded-recurrence' || shape === 'bounded-recurrence') {
+        return 'Title not drawn on the chart: bounded recurrences are not labelled.';
+    }
+    return undefined;
+}
+
+/**
+ * Wave lines for the hover: the wave summary on a wave declaration, the
+ * effective wave on an item. Empty when the file declares no waves.
+ */
+function waveLines(file: NowlineFile, entity: NamedEntity): string[] {
+    if (!isWaveDeclaration(entity) && !isItemDeclaration(entity)) return [];
+    const waves = ownWaves(file);
+    if (waves.length === 0) return [];
+    const waveIds = waveIndexMap(file);
+    const lanes = file.roadmapEntries.filter(isSwimlaneDeclaration);
+    const assignment = assignWaves(lanes, waveIds);
+    if (isWaveDeclaration(entity)) return waveSummary(entity, waves, waveIds, assignment);
+    const ew = assignment.waveOf.get(entity);
+    if (ew === undefined) return ['background (no wave)'];
+    const wave = waves[ew - 1];
+    const source = waveSource(entity, assignment);
+    if (source === entity) return [`wave "${wave.name}"`];
+    return [`wave "${wave.name}" (inherited from ${describeContainer(source)})`];
+}
+
+function waveSummary(
+    wave: WaveDeclaration,
+    waves: readonly WaveDeclaration[],
+    waveIds: ReadonlyMap<string, number>,
+    assignment: WaveAssignment,
+): string[] {
+    const k = wave.name ? waveIds.get(wave.name) : undefined;
+    // A repeated wave id (NL.E0300) only counts its first declaration.
+    if (k === undefined || waves[k - 1] !== wave) return [];
+    const lines = [`wave ${k} of ${waves.length}`];
+    if (wave.description?.text) lines.push('', wave.description.text);
+    let members = 0;
+    for (const [node, ew] of assignment.waveOf) {
+        if (ew === k && isItemDeclaration(node)) members++;
+    }
+    lines.push('', `${members} ${members === 1 ? 'member' : 'members'}`);
+    const labels = wave.properties.find((p) => propKey(p) === 'labels');
+    const labelIds = labels?.values ?? (labels?.value ? [labels.value] : []);
+    if (labelIds.length) lines.push('', `labels: ${labelIds.join(', ')}`);
+    return lines;
+}
+
+// The node that sets an item's effective wave: the outermost of the item and
+// its enclosing groups / parallels that has one. An enclosing container's wave
+// wins over the item's own (specs/waves.md §4.4), and it reaches the item only
+// through the containers in between.
+function waveSource(item: AstNode, assignment: WaveAssignment): AstNode {
+    let source = item;
+    let node = item.$container;
+    while ((isGroupBlock(node) || isParallelBlock(node)) && assignment.waveOf.has(node)) {
+        source = node;
+        node = node.$container;
+    }
+    return source;
+}
+
+function describeContainer(node: AstNode): string {
+    const kind = entityKind(node);
+    const named = node as { name?: string; title?: string };
+    const label = named.name ?? (named.title === undefined ? undefined : singleLine(named.title));
+    return label ? `${kind} "${label}"` : kind;
+}

package/src/providers/references.ts

@@ -8,6 +8,7 @@ import {
     declarationAt,
     fileFromDocument,
     findDeclarationRange,
+    isCalendarDeclaration,
     leafAt,
     propertyValueAt,
     propKey,
@@ -66,6 +67,7 @@ export class NowlineReferencesProvider implements ReferencesProvider {
 
 function resolveTargetId(leaf: CstNode): string | undefined {
     const decl = declarationAt(leaf);
+    if (decl && isCalendarDeclaration(decl)) return undefined;
     if (decl?.name) return decl.name;
     const propHit = propertyValueAt(leaf);
     if (propHit && REFERENCE_PROP_KEYS.has(propKey(propHit.prop))) {

package/src/providers/rename.ts

@@ -16,6 +16,7 @@ import {
     declarationAt,
     fileFromDocument,
     findDeclarationRange,
+    isCalendarDeclaration,
     leafAt,
     propertyValueAt,
     propKey,
@@ -93,7 +94,7 @@ function renameRangeAt(document: LangiumDocument, position: Position): RenameTar
     const leaf = leafAt(document, offset);
     if (!leaf) return undefined;
     const decl = declarationAt(leaf);
-    if (decl?.name === leaf.text) {
+    if (decl && !isCalendarDeclaration(decl) && decl.name === leaf.text) {
         return { id: decl.name, range: leaf.range };
     }
     const hit = propertyValueAt(leaf);