modelable 1.0.0__py3-none-any.whl

modelable/lsp/hover.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from lsprotocol import types
+
+from modelable.llm.context import build_model_summary, build_projection_summary, parse_model_ref
+from modelable.lsp.workspace import LspWorkspaceIndex
+from modelable.registry.resolver import resolve_model_ref
+
+_QUALIFIED_REF_PATTERN = re.compile(
+    r"(?P<domain>[A-Za-z_][A-Za-z0-9_]*)\.(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*@\s*(?P<version>\d+)"
+)
+_REF_TYPE_PATTERN = re.compile(r"ref\s*<\s*(?P<domain>[A-Za-z_][A-Za-z0-9_]*)\.(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*>")
+_FIELD_REF_PATTERN = re.compile(r"(?P<alias>[A-Za-z_][A-Za-z0-9_]*)\.(?P<field>[A-Za-z_][A-Za-z0-9_]*)")
+_DECL_PATTERN = re.compile(
+    r"^\s*(?P<kind>entity|aggregate|event|value|projection)\s+"
+    r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*@\s*(?P<version>\d+)"
+)
+_DOMAIN_PATTERN = re.compile(r'^\s*domain\s+(?:"(?P<quoted>[^"]+)"|(?P<name>[A-Za-z_][A-Za-z0-9_]*))')
+_WORD_PATTERN = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+
+
+@dataclass(frozen=True)
+class HoverInfo:
+    markdown: str
+    line: int
+    start: int
+    end: int
+
+
+def build_hover(index: LspWorkspaceIndex, uri: str, line: int, character: int) -> types.Hover | None:
+    source = index.documents.get(uri)
+    workspace = index.workspace
+    if source is None or workspace is None:
+        return None
+
+    lines = source.text.splitlines()
+    if line < 0 or line >= len(lines):
+        return None
+    text_line = lines[line]
+
+    for match in _QUALIFIED_REF_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            ref = f"{match.group('domain')}.{match.group('name')}@{match.group('version')}"
+            return _make_ref_hover(workspace, ref, line, match.start(), match.end())
+
+    for match in _REF_TYPE_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            hover = _make_unversioned_ref_hover(
+                workspace, match.group("domain"), match.group("name"), line, match.start(), match.end()
+            )
+            if hover is not None:
+                return hover
+
+    for match in _FIELD_REF_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            info = _hover_for_field_reference(
+                workspace,
+                source.text,
+                line,
+                match.group("alias"),
+                match.group("field"),
+                match.start(),
+                match.end(),
+            )
+            if info is not None:
+                return _hover_from_info(info)
+
+    word = _word_at(text_line, character)
+    if word is None:
+        return None
+
+    info = _hover_for_bare_word(workspace, source.text, line, word)
+    if info is not None:
+        start, end = _word_span(text_line, character)
+        return _hover_from_info(HoverInfo(markdown=_markdown_block(info), line=line, start=start, end=end))
+    return None
+
+
+def _make_ref_hover(workspace, ref: str, line: int, start: int, end: int) -> types.Hover | None:
+    model_ref = parse_model_ref(ref)
+    domain = next((d for d in workspace.mdl.domains if d.name == model_ref.domain), None)
+    if domain is None:
+        return None
+
+    if model_ref.name in domain.models:
+        summary = build_model_summary(workspace, ref)
+    elif model_ref.name in domain.projections:
+        summary = build_projection_summary(workspace, ref)
+    else:
+        return None
+
+    return _hover_from_info(HoverInfo(markdown=_markdown_block(summary), line=line, start=start, end=end))
+
+
+def _make_unversioned_ref_hover(
+    workspace, domain_name: str, name: str, line: int, start: int, end: int
+) -> types.Hover | None:
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    if name in domain.models:
+        latest = max(domain.models[name], key=lambda v: v.version)
+        ref = f"{domain_name}.{name}@{latest.version}"
+        return _make_ref_hover(workspace, ref, line, start, end)
+    if name in domain.projections:
+        latest = max(domain.projections[name], key=lambda v: v.version)
+        ref = f"{domain_name}.{name}@{latest.version}"
+        return _make_ref_hover(workspace, ref, line, start, end)
+    return None
+
+
+def _hover_for_bare_word(workspace, text: str, line: int, word: str) -> str | None:
+    scope = _current_scope(text, line)
+    if scope is None:
+        return None
+    domain_name, kind, name, version = scope
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+
+    if kind == "model":
+        versions = domain.models.get(name)
+        if not versions:
+            return None
+        model_version = next((item for item in versions if item.version == version), None)
+        if model_version is None:
+            return None
+        if word == name:
+            return build_model_summary(workspace, f"{domain_name}.{name}@{version}")
+        field = next((item for item in model_version.fields if item.name == word), None)
+        if field is None:
+            return None
+        flags = []
+        if field.is_key:
+            flags.append("key")
+        if field.is_pii:
+            flags.append("pii")
+        if field.classification:
+            flags.append(f"classification={field.classification.value}")
+        suffix = f" [{', '.join(flags)}]" if flags else ""
+        return (
+            f"{domain_name}.{name}@{version}.{field.name}\n"
+            f"type: {field.type.kind}\n"
+            f"optional: {'yes' if field.optional else 'no'}{suffix}"
+        )
+
+    versions = domain.projections.get(name)
+    if not versions:
+        return None
+    projection_version = next((item for item in versions if item.version == version), None)
+    if projection_version is None:
+        return None
+    if word == name:
+        return build_projection_summary(workspace, f"{domain_name}.{name}@{version}")
+    field = next((item for item in projection_version.fields if item.name == word), None)
+    if field is None:
+        return None
+    return f"{domain_name}.{name}@{version}.{field.name}\nmapping: {_mapping_text(field)}"
+
+
+def _hover_for_field_reference(
+    workspace,
+    text: str,
+    line: int,
+    alias: str,
+    field_name: str,
+    start: int,
+    end: int,
+) -> HoverInfo | None:
+    scope = _current_scope(text, line)
+    if scope is None:
+        return None
+    domain_name, kind, name, version = scope
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    if kind == "model":
+        versions = domain.models.get(name)
+        if not versions:
+            return None
+        model_version = next((item for item in versions if item.version == version), None)
+        if model_version is None:
+            return None
+        field = next((item for item in model_version.fields if item.name == field_name), None)
+        if field is None:
+            return None
+        flags = []
+        if field.is_key:
+            flags.append("key")
+        if field.is_pii:
+            flags.append("pii")
+        if field.classification:
+            flags.append(f"classification={field.classification.value}")
+        suffix = f" [{', '.join(flags)}]" if flags else ""
+        return HoverInfo(
+            markdown=_markdown_block(
+                f"{domain_name}.{name}@{version}.{field.name}\n"
+                f"type: {field.type.kind}\n"
+                f"optional: {'yes' if field.optional else 'no'}{suffix}"
+            ),
+            line=line,
+            start=start,
+            end=end,
+        )
+    versions = domain.projections.get(name)
+    if not versions:
+        return None
+    projection_version = next((item for item in versions if item.version == version), None)
+    if projection_version is None:
+        return None
+    for source_ref in [projection_version.source, *projection_version.joins]:
+        if source_ref.alias != alias:
+            continue
+        try:
+            resolved = resolve_model_ref(
+                workspace.mdl,
+                source_ref.model,
+                source_ref.version,
+            )
+        except LookupError:
+            break
+        return _hover_for_source_field(
+            workspace,
+            resolved.domain_name,
+            resolved.model_name,
+            resolved.version.version,
+            field_name,
+            line,
+            start,
+            end,
+        )
+    field = next((item for item in projection_version.fields if item.name == field_name), None)
+    if field is None:
+        return None
+    return HoverInfo(
+        markdown=_markdown_block(f"{domain_name}.{name}@{version}.{field.name}\nmapping: {_mapping_text(field)}"),
+        line=line,
+        start=start,
+        end=end,
+    )
+
+
+def _hover_for_source_field(
+    workspace,
+    domain_name: str,
+    model_name: str,
+    version: int,
+    field_name: str,
+    line: int,
+    start: int,
+    end: int,
+) -> HoverInfo | None:
+    source_version = _source_version(workspace, domain_name, model_name, version)
+    if source_version is None:
+        return None
+    source_field = next((item for item in getattr(source_version, "fields", []) if item.name == field_name), None)
+    if source_field is None:
+        return None
+
+    if getattr(source_field, "mapping", None) is not None:
+        return HoverInfo(
+            markdown=_markdown_block(
+                f"{domain_name}.{model_name}@{version}.{source_field.name}\nmapping: {_mapping_text(source_field)}"
+            ),
+            line=line,
+            start=start,
+            end=end,
+        )
+
+    flags = []
+    if source_field.is_key:
+        flags.append("key")
+    if source_field.is_pii:
+        flags.append("pii")
+    if source_field.classification:
+        flags.append(f"classification={source_field.classification.value}")
+    suffix = f" [{', '.join(flags)}]" if flags else ""
+    return HoverInfo(
+        markdown=_markdown_block(
+            f"{domain_name}.{model_name}@{version}.{source_field.name}\n"
+            f"type: {source_field.type.kind}\n"
+            f"optional: {'yes' if source_field.optional else 'no'}{suffix}"
+        ),
+        line=line,
+        start=start,
+        end=end,
+    )
+
+
+def _source_version(workspace, domain_name: str, model_name: str, version: int):
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    versions = domain.models.get(model_name, [])
+    source_version = next((item for item in versions if item.version == version), None)
+    if source_version is not None:
+        return source_version
+    versions = domain.projections.get(model_name, [])
+    return next((item for item in versions if item.version == version), None)
+
+
+def _hover_from_info(info: HoverInfo) -> types.Hover:
+    return types.Hover(
+        contents=types.MarkupContent(kind=types.MarkupKind.Markdown, value=info.markdown),
+        range=types.Range(
+            start=types.Position(line=info.line, character=info.start),
+            end=types.Position(line=info.line, character=info.end),
+        ),
+    )
+
+
+def _current_scope(text: str, line: int) -> tuple[str, str, str, int] | None:
+    lines = text.splitlines()
+    current_domain: str | None = None
+    current_kind: str | None = None
+    current_name: str | None = None
+    current_version: int | None = None
+    for item in lines[: line + 1]:
+        domain_match = _DOMAIN_PATTERN.match(item)
+        if domain_match:
+            current_domain = domain_match.group("quoted") or domain_match.group("name")
+            current_kind = None
+            current_name = None
+            current_version = None
+            continue
+        decl_match = _DECL_PATTERN.match(item)
+        if decl_match and current_domain is not None:
+            current_kind = "model" if decl_match.group("kind") != "projection" else "projection"
+            current_name = decl_match.group("name")
+            current_version = int(decl_match.group("version"))
+    if current_domain and current_kind and current_name and current_version is not None:
+        return current_domain, current_kind, current_name, current_version
+    return None
+
+
+def _word_at(text_line: str, character: int) -> str | None:
+    for match in _WORD_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            return match.group(0)
+    return None
+
+
+def _word_span(text_line: str, character: int) -> tuple[int, int]:
+    for match in _WORD_PATTERN.finditer(text_line):
+        if _contains(match.start(), match.end(), character):
+            return match.start(), match.end()
+    return character, character
+
+
+def _contains(start: int, end: int, character: int) -> bool:
+    return start <= character <= max(end - 1, start)
+
+
+def _markdown_block(text: str) -> str:
+    return f"```text\n{text}\n```"
+
+
+def _mapping_text(field) -> str:
+    mapping = getattr(field, "mapping", None)
+    if mapping is None:
+        return "unknown"
+    kind = getattr(mapping, "kind", None)
+    if kind == "direct":
+        return f"direct {mapping.source_alias}.{mapping.source_field}"
+    if kind == "computed":
+        return f"computed {mapping.expression}"
+    return "unknown"

modelable/lsp/inlay_hints.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import re
+
+from lsprotocol import types
+
+from modelable.lsp.workspace import LspWorkspaceIndex
+from modelable.registry.resolver import resolve_model_ref
+
+_DOMAIN_PATTERN = re.compile(r'^\s*domain\s+(?:"(?P<quoted>[^"]+)"|(?P<name>[A-Za-z_][A-Za-z0-9_]*))')
+_DECL_PATTERN = re.compile(
+    r"^\s*(?P<kind>entity|aggregate|event|value|projection)\s+"
+    r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*@\s*(?P<version>\d+)"
+)
+_SOURCE_PATTERN = re.compile(
+    r"^\s*(?:left\s+)?(?:from|join)\s+"
+    r"(?P<domain>[A-Za-z_][A-Za-z0-9_.-]*)\.(?P<model>[A-Za-z_][A-Za-z0-9_.-]*)"
+    r"\s*@\s*(?P<version>\d+)(?:\s+as\s+(?P<alias>[A-Za-z_][A-Za-z0-9_]*))?"
+)
+_DIRECT_MAPPING_PATTERN = re.compile(
+    r"^\s*(?:@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s+)*"
+    r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*<-\s*"
+    r"(?P<alias>[A-Za-z_][A-Za-z0-9_]*)\.(?P<field>[A-Za-z_][A-Za-z0-9_]*)"
+)
+
+
+def build_inlay_hints(
+    index: LspWorkspaceIndex,
+    uri: str,
+    range: types.Range,
+) -> list[types.InlayHint] | None:
+    source = index.documents.get(uri)
+    workspace = index.workspace
+    if source is None or workspace is None:
+        return None
+
+    hints: list[types.InlayHint] = []
+    lines = source.text.splitlines()
+    current_domain: str | None = None
+    in_projection = False
+    alias_map: dict[str, tuple[str, str, int]] = {}
+
+    for line_no, line in enumerate(lines):
+        domain_match = _DOMAIN_PATTERN.match(line)
+        if domain_match:
+            current_domain = domain_match.group("quoted") or domain_match.group("name")
+            in_projection = False
+            alias_map = {}
+            continue
+
+        decl_match = _DECL_PATTERN.match(line)
+        if decl_match and current_domain is not None:
+            in_projection = decl_match.group("kind") == "projection"
+            alias_map = {}
+            continue
+
+        source_match = _SOURCE_PATTERN.match(line)
+        if source_match and in_projection:
+            domain_name = source_match.group("domain")
+            model_name = source_match.group("model")
+            version = int(source_match.group("version"))
+            alias = source_match.group("alias")
+            if alias:
+                try:
+                    resolved = resolve_model_ref(workspace.mdl, f"{domain_name}.{model_name}", version)
+                    alias_map[alias] = (resolved.domain_name, resolved.model_name, resolved.version.version)
+                except LookupError:
+                    pass
+            if range.start.line <= line_no <= range.end.line:
+                kind_label = _resolve_model_kind(workspace, domain_name, model_name, version)
+                if kind_label is not None:
+                    hints.append(
+                        types.InlayHint(
+                            position=types.Position(line=line_no, character=source_match.end("version")),
+                            label=f" [{kind_label}]",
+                            kind=types.InlayHintKind.Type,
+                        )
+                    )
+            continue
+
+        if not in_projection or current_domain is None:
+            continue
+
+        if range.start.line <= line_no <= range.end.line:
+            direct_match = _DIRECT_MAPPING_PATTERN.match(line)
+            if direct_match:
+                alias = direct_match.group("alias")
+                source_field_name = direct_match.group("field")
+                target = alias_map.get(alias)
+                if target is not None:
+                    field_type = _resolve_field_type(workspace, *target, source_field_name)
+                    if field_type is not None:
+                        hints.append(
+                            types.InlayHint(
+                                position=types.Position(line=line_no, character=direct_match.end("name")),
+                                label=f": {field_type}",
+                                kind=types.InlayHintKind.Type,
+                            )
+                        )
+
+    return hints
+
+
+def _resolve_model_kind(workspace, domain_name: str, model_name: str, version: int) -> str | None:
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    versions = domain.models.get(model_name, [])
+    model_version = next((item for item in versions if item.version == version), None)
+    if model_version is not None:
+        return model_version.model_kind.value
+    versions = domain.projections.get(model_name, [])
+    if any(item.version == version for item in versions):
+        return "projection"
+    return None
+
+
+def _resolve_field_type(
+    workspace,
+    domain_name: str,
+    model_name: str,
+    version: int,
+    field_name: str,
+) -> str | None:
+    domain = next((d for d in workspace.mdl.domains if d.name == domain_name), None)
+    if domain is None:
+        return None
+    versions = domain.models.get(model_name, [])
+    model_version = next((item for item in versions if item.version == version), None)
+    if model_version is not None:
+        field = next((f for f in model_version.fields if f.name == field_name), None)
+        if field is None:
+            return None
+        return field.type.kind
+    # Source is a projection: follow a direct mapping one level to its backing model field
+    proj_versions = domain.projections.get(model_name, [])
+    proj_version = next((item for item in proj_versions if item.version == version), None)
+    if proj_version is None:
+        return None
+    proj_field = next((f for f in proj_version.fields if f.name == field_name), None)
+    if proj_field is None or proj_field.mapping.kind != "direct":
+        return None
+    mapping = proj_field.mapping
+    for source_ref in [proj_version.source, *proj_version.joins]:
+        if source_ref.alias != mapping.source_alias:
+            continue
+        try:
+            resolved = resolve_model_ref(workspace.mdl, source_ref.model, source_ref.version)
+        except LookupError:
+            return None
+        return _resolve_field_type(
+            workspace,
+            resolved.domain_name,
+            resolved.model_name,
+            resolved.version.version,
+            mapping.source_field,
+        )
+    return None