loomweave-plugin-python 1.0.0__py3-none-any.whl

loomweave_plugin_python/__init__.py

@@ -0,0 +1,3 @@
+"""loomweave-plugin-python — Python language plugin for Loomweave."""
+
+__version__ = "1.0.0"

loomweave_plugin_python/__main__.py

@@ -0,0 +1,15 @@
+"""Entry point for the ``loomweave-plugin-python`` executable.
+
+Installs stdout discipline (``stdout_guard``) and hands control to the
+JSON-RPC server loop. ``sys.exit`` threads the server's exit code out to
+the host process.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from loomweave_plugin_python.server import main
+
+if __name__ == "__main__":
+    sys.exit(main())

loomweave_plugin_python/call_resolver.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal, NotRequired, Protocol, TypedDict
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+
+class CallsEdgeProperties(TypedDict):
+    candidates: list[str]
+
+
+class CallsRawEdge(TypedDict):
+    kind: Literal["calls"]
+    from_id: str
+    to_id: str
+    source_byte_start: int
+    source_byte_end: int
+    confidence: Literal["resolved", "ambiguous"]
+    properties: NotRequired[CallsEdgeProperties]
+
+
+class Finding(TypedDict):
+    subcode: str
+    severity: Literal["info", "warning", "error"]
+    message: str
+    metadata: dict[str, object]
+
+
+class UnresolvedCallSite(TypedDict):
+    caller_entity_id: str
+    site_ordinal: int
+    source_byte_start: int
+    source_byte_end: int
+    callee_expr: str
+
+
+@dataclass
+class CallResolutionResult:
+    edges: list[CallsRawEdge] = field(default_factory=list)
+    unresolved_call_sites_total: int = 0
+    unresolved_call_sites: list[UnresolvedCallSite] = field(default_factory=list)
+    pyright_query_latency_ms: list[int] = field(default_factory=list)
+    pyright_index_parse_latency_ms: list[int] = field(default_factory=list)
+    findings: list[Finding] = field(default_factory=list)
+
+
+class CallResolver(Protocol):
+    def resolve_calls(
+        self,
+        file_path: str | Path,
+        function_ids: Sequence[str],
+    ) -> CallResolutionResult: ...
+
+
+class NoOpCallResolver:
+    def resolve_calls(
+        self,
+        file_path: str | Path,
+        function_ids: Sequence[str],
+    ) -> CallResolutionResult:
+        _ = (file_path, function_ids)
+        return CallResolutionResult()

loomweave_plugin_python/entity_id.py

@@ -0,0 +1,75 @@
+"""L2 3-segment EntityId assembler matching WP1's Rust ``entity_id()`` byte-for-byte.
+
+Per ADR-003 + ADR-022, every Loomweave entity has a 3-segment ID of the
+form ``{plugin_id}:{kind}:{canonical_qualified_name}``.
+
+Validation (mirrors ``crates/loomweave-core/src/entity_id.rs``):
+
+- ``plugin_id`` and ``kind`` must match the identifier grammar
+  ``[a-z][a-z0-9_]*`` (ADR-022).
+- No segment may contain a literal ``:`` (reserved separator).
+- No segment may be empty.
+
+The shared fixture ``fixtures/entity_id.json`` (Task 5) drives the
+cross-language parity check: both the Rust assembler and this Python
+assembler consume the same fixture rows and must produce identical
+strings byte-for-byte.
+"""
+
+from __future__ import annotations
+
+import re
+
+_GRAMMAR = re.compile(r"^[a-z][a-z0-9_]*$")
+
+
+class EntityIdError(ValueError):
+    """Base class for all ``entity_id()`` validation failures."""
+
+
+class EmptySegmentError(EntityIdError):
+    """A segment (``plugin_id``, ``kind``, or ``canonical_qualified_name``) was empty."""
+
+    def __init__(self, field: str) -> None:
+        super().__init__(f"segment {field} empty")
+        self.field = field
+
+
+class GrammarViolationError(EntityIdError):
+    """A segment did not match the ADR-022 grammar ``[a-z][a-z0-9_]*``."""
+
+    def __init__(self, field: str, value: str) -> None:
+        super().__init__(f"segment {field} violates ADR-022 grammar [a-z][a-z0-9_]*: {value!r}")
+        self.field = field
+        self.value = value
+
+
+class SegmentContainsColonError(EntityIdError):
+    """A segment contained the reserved ``:`` separator (UQ-WP1-07)."""
+
+    def __init__(self, field: str, value: str) -> None:
+        super().__init__(f"segment {field} contains reserved ':' separator: {value!r}")
+        self.field = field
+        self.value = value
+
+
+def _validate_grammar(field: str, value: str) -> None:
+    """Mirror ``validate_grammar`` in the Rust side — empty, colon, then regex."""
+    if not value:
+        raise EmptySegmentError(field)
+    if ":" in value:
+        raise SegmentContainsColonError(field, value)
+    if not _GRAMMAR.fullmatch(value):
+        raise GrammarViolationError(field, value)
+
+
+def entity_id(plugin_id: str, kind: str, canonical_qualified_name: str) -> str:
+    """Assemble the 3-segment EntityId string with full validation."""
+    _validate_grammar("plugin_id", plugin_id)
+    _validate_grammar("kind", kind)
+    qn_field = "canonical_qualified_name"
+    if not canonical_qualified_name:
+        raise EmptySegmentError(qn_field)
+    if ":" in canonical_qualified_name:
+        raise SegmentContainsColonError(qn_field, canonical_qualified_name)
+    return f"{plugin_id}:{kind}:{canonical_qualified_name}"