feat: add codeLens, inlayHint, references, workspaceSymbol, semanticTokens, codeAction LSP features (#314)

- Add reqstool/details custom request for structured REQ/SVC/MVR data
- Extend hover with "Open Details" command link
- Add textDocument/codeLens (verification status above annotations)
- Add textDocument/inlayHint (title inline after ID)
- Add textDocument/references (find all usages across open docs + YAML)
- Add workspace/symbol (quick-search REQ/SVC IDs)
- Add textDocument/semanticTokens/full (color-code deprecated/obsolete)
- Add textDocument/codeAction (quick fixes for unknown/deprecated IDs)
- Add get_mvr() and get_yaml_paths() to ProjectState
- Add _get() and _first_project() shared helpers to server.py

Signed-off-by: Jimisola Laursen <jimisola@jimisola.com>

Author: jimisola

src/reqstool/lsp/features/code_actions.py

@@ -0,0 +1,103 @@
+# Copyright © LFV
+
+from __future__ import annotations
+
+import re
+
+from lsprotocol import types
+
+from reqstool.lsp.annotation_parser import annotation_at_position
+from reqstool.lsp.project_state import ProjectState
+
+# Patterns matching diagnostic messages from diagnostics.py
+_UNKNOWN_REQ_RE = re.compile(r"Unknown requirement: (.+)")
+_UNKNOWN_SVC_RE = re.compile(r"Unknown SVC: (.+)")
+_LIFECYCLE_RE = re.compile(r"(Requirement|SVC) (.+) is (?:deprecated|obsolete)")
+
+
+def handle_code_actions(
+    uri: str,
+    range_: types.Range,
+    context: types.CodeActionContext,
+    text: str,
+    language_id: str,
+    project: ProjectState | None,
+) -> list[types.CodeAction]:
+    only = set(context.only) if context.only else None
+    actions = _actions_from_diagnostics(uri, context.diagnostics, only)
+    actions += _source_action(uri, range_, text, language_id, project, only)
+    return actions
+
+
+def _actions_from_diagnostics(
+    uri: str,
+    diagnostics: list,
+    only: set | None,
+) -> list[types.CodeAction]:
+    actions: list[types.CodeAction] = []
+    if only is not None and types.CodeActionKind.QuickFix not in only:
+        return actions
+    for diag in diagnostics:
+        if diag.source != "reqstool":
+            continue
+        action = _action_from_message(diag.message, uri)
+        if action is not None:
+            actions.append(action)
+    return actions
+
+
+def _action_from_message(msg: str, uri: str) -> types.CodeAction | None:
+    m = _UNKNOWN_REQ_RE.match(msg)
+    if m:
+        raw_id = m.group(1)
+        return _make_action(f"Open Details for {raw_id}", raw_id, uri, "requirement", types.CodeActionKind.QuickFix)
+    m = _UNKNOWN_SVC_RE.match(msg)
+    if m:
+        raw_id = m.group(1)
+        return _make_action(f"Open Details for {raw_id}", raw_id, uri, "svc", types.CodeActionKind.QuickFix)
+    m = _LIFECYCLE_RE.match(msg)
+    if m:
+        kind_label, raw_id = m.group(1), m.group(2)
+        item_type = "requirement" if kind_label == "Requirement" else "svc"
+        return _make_action(f"View details for {raw_id}", raw_id, uri, item_type, types.CodeActionKind.QuickFix)
+    return None
+
+
+def _source_action(
+    uri: str,
+    range_: types.Range,
+    text: str,
+    language_id: str,
+    project: ProjectState | None,
+    only: set | None,
+) -> list[types.CodeAction]:
+    if project is None or not project.ready:
+        return []
+    if only is not None and types.CodeActionKind.Source not in only:
+        return []
+    match = annotation_at_position(text, range_.start.line, range_.start.character, language_id)
+    if match is None:
+        return []
+    item_type = "requirement" if match.kind == "Requirements" else "svc"
+    known = project.get_requirement(match.raw_id) if match.kind == "Requirements" else project.get_svc(match.raw_id)
+    if known is None:
+        return []
+    return [_make_action("Open Details", match.raw_id, uri, item_type, types.CodeActionKind.Source)]
+
+
+def _make_action(
+    title: str,
+    raw_id: str,
+    uri: str,
+    item_type: str,
+    kind: types.CodeActionKind,
+) -> types.CodeAction:
+    return types.CodeAction(
+        title=title,
+        kind=kind,
+        command=types.Command(
+            title=title,
+            command="reqstool.openDetails",
+            arguments=[{"id": raw_id, "uri": uri, "type": item_type}],
+        ),
+    )

src/reqstool/lsp/features/codelens.py

@@ -0,0 +1,93 @@
+# Copyright © LFV
+
+from __future__ import annotations
+
+from lsprotocol import types
+
+from reqstool.lsp.annotation_parser import find_all_annotations
+from reqstool.lsp.project_state import ProjectState
+
+
+def handle_code_lens(
+    uri: str,
+    text: str,
+    language_id: str,
+    project: ProjectState | None,
+) -> list[types.CodeLens]:
+    if project is None or not project.ready:
+        return []
+
+    annotations = find_all_annotations(text, language_id)
+    if not annotations:
+        return []
+
+    # Group annotation matches by (line, kind)
+    by_line: dict[tuple[int, str], list[str]] = {}
+    for match in annotations:
+        key = (match.line, match.kind)
+        by_line.setdefault(key, []).append(match.raw_id)
+
+    lines = text.splitlines()
+    result: list[types.CodeLens] = []
+
+    for (line_idx, kind), ids in by_line.items():
+        line_len = len(lines[line_idx]) if line_idx < len(lines) else 0
+        lens_range = types.Range(
+            start=types.Position(line=line_idx, character=0),
+            end=types.Position(line=line_idx, character=line_len),
+        )
+
+        if kind == "Requirements":
+            label = _req_label(ids, project)
+            item_type = "requirement"
+        else:
+            label = _svc_label(ids, project)
+            item_type = "svc"
+
+        result.append(
+            types.CodeLens(
+                range=lens_range,
+                command=types.Command(
+                    title=label,
+                    command="reqstool.openDetails",
+                    arguments=[{"id": ids[0], "uri": uri, "type": item_type}],
+                ),
+            )
+        )
+
+    return result
+
+
+def _req_label(ids: list[str], project: ProjectState) -> str:
+    all_svcs = []
+    for raw_id in ids:
+        all_svcs.extend(project.get_svcs_for_req(raw_id))
+
+    pass_count = 0
+    fail_count = 0
+    for svc in all_svcs:
+        for mvr in project.get_mvrs_for_svc(svc.id.id):
+            if mvr.passed:
+                pass_count += 1
+            else:
+                fail_count += 1
+
+    id_str = ", ".join(ids)
+    svc_count = len(all_svcs)
+
+    if pass_count == 0 and fail_count == 0:
+        return f"{id_str}: {svc_count} SVCs"
+    return f"{id_str}: {svc_count} SVCs · {pass_count}✓ {fail_count}✗"
+
+
+def _svc_label(ids: list[str], project: ProjectState) -> str:
+    id_str = ", ".join(ids)
+    if len(ids) == 1:
+        svc = project.get_svc(ids[0])
+        if svc is not None:
+            mvrs = project.get_mvrs_for_svc(ids[0])
+            if mvrs:
+                result = "pass" if all(m.passed for m in mvrs) else "fail"
+                return f"{id_str}: {svc.verification.value} · {result}"
+            return f"{id_str}: {svc.verification.value}"
+    return id_str

src/reqstool/lsp/features/details.py

@@ -0,0 +1,82 @@
+# Copyright © LFV
+
+from __future__ import annotations
+
+from reqstool.lsp.project_state import ProjectState
+
+
+def get_requirement_details(raw_id: str, project: ProjectState) -> dict | None:
+    req = project.get_requirement(raw_id)
+    if req is None:
+        return None
+    svcs = project.get_svcs_for_req(raw_id)
+    return {
+        "type": "requirement",
+        "id": req.id.id,
+        "urn": str(req.id),
+        "title": req.title,
+        "significance": req.significance.value,
+        "description": req.description,
+        "rationale": req.rationale or "",
+        "revision": str(req.revision),
+        "lifecycle": {
+            "state": req.lifecycle.state.value,
+            "reason": req.lifecycle.reason or "",
+        },
+        "categories": [c.value for c in req.categories],
+        "implementation": req.implementation.value,
+        "svcs": [
+            {
+                "id": s.id.id,
+                "urn": str(s.id),
+                "title": s.title,
+                "verification": s.verification.value,
+            }
+            for s in svcs
+        ],
+    }
+
+
+def get_svc_details(raw_id: str, project: ProjectState) -> dict | None:
+    svc = project.get_svc(raw_id)
+    if svc is None:
+        return None
+    mvrs = project.get_mvrs_for_svc(raw_id)
+    return {
+        "type": "svc",
+        "id": svc.id.id,
+        "urn": str(svc.id),
+        "title": svc.title,
+        "description": svc.description or "",
+        "verification": svc.verification.value,
+        "instructions": svc.instructions or "",
+        "revision": str(svc.revision),
+        "lifecycle": {
+            "state": svc.lifecycle.state.value,
+            "reason": svc.lifecycle.reason or "",
+        },
+        "requirement_ids": [{"id": r.id, "urn": str(r)} for r in svc.requirement_ids],
+        "mvrs": [
+            {
+                "id": m.id.id,
+                "urn": str(m.id),
+                "passed": m.passed,
+                "comment": m.comment or "",
+            }
+            for m in mvrs
+        ],
+    }
+
+
+def get_mvr_details(raw_id: str, project: ProjectState) -> dict | None:
+    mvr = project.get_mvr(raw_id)
+    if mvr is None:
+        return None
+    return {
+        "type": "mvr",
+        "id": mvr.id.id,
+        "urn": str(mvr.id),
+        "passed": mvr.passed,
+        "comment": mvr.comment or "",
+        "svc_ids": [{"id": s.id, "urn": str(s)} for s in mvr.svc_ids],
+    }

src/reqstool/lsp/features/hover.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import json
 import os
 import re
+import urllib.parse
 
 from lsprotocol import types
 
@@ -31,10 +33,11 @@ def handle_hover(
     if basename in REQSTOOL_YAML_FILES:
         return _hover_yaml(text, position, basename)
     else:
-        return _hover_source(text, position, language_id, project)
+        return _hover_source(uri, text, position, language_id, project)
 
 
 def _hover_source(
+    uri: str,
     text: str,
     position: types.Position,
     language_id: str,
@@ -57,14 +60,19 @@ def _hover_source(
         )
 
     if match.kind == "Requirements":
-        return _hover_requirement(match.raw_id, match, project)
+        return _hover_requirement(match.raw_id, match, project, uri)
     elif match.kind == "SVCs":
-        return _hover_svc(match.raw_id, match, project)
+        return _hover_svc(match.raw_id, match, project, uri)
 
     return None
 
 
-def _hover_requirement(raw_id: str, match, project: ProjectState) -> types.Hover | None:
+def _open_details_link(raw_id: str, uri: str, kind: str) -> str:
+    args = urllib.parse.quote(json.dumps({"id": raw_id, "uri": uri, "type": kind}))
+    return f"[Open Details](command:reqstool.openDetails?{args})"
+
+
+def _hover_requirement(raw_id: str, match, project: ProjectState, uri: str) -> types.Hover | None:
     req = project.get_requirement(raw_id)
     if req is None:
         md = f"**Unknown requirement**: `{raw_id}`"
@@ -87,6 +95,8 @@ def _hover_requirement(raw_id: str, match, project: ProjectState) -> types.Hover
                 f"**Categories**: {categories}",
                 f"**Lifecycle**: {req.lifecycle.state.value}",
                 f"**SVCs**: {svc_ids}",
+                "---",
+                _open_details_link(raw_id, uri, "requirement"),
             ]
         )
         md = "\n\n".join(parts)
@@ -100,7 +110,7 @@ def _hover_requirement(raw_id: str, match, project: ProjectState) -> types.Hover
     )
 
 
-def _hover_svc(raw_id: str, match, project: ProjectState) -> types.Hover | None:
+def _hover_svc(raw_id: str, match, project: ProjectState, uri: str) -> types.Hover | None:
     svc = project.get_svc(raw_id)
     if svc is None:
         md = f"**Unknown SVC**: `{raw_id}`"
@@ -125,6 +135,8 @@ def _hover_svc(raw_id: str, match, project: ProjectState) -> types.Hover | None:
                 f"**Lifecycle**: {svc.lifecycle.state.value}",
                 f"**Requirements**: {req_ids}",
                 f"**MVRs**: {mvr_info}",
+                "---",
+                _open_details_link(raw_id, uri, "svc"),
             ]
         )
         md = "\n\n".join(parts)