context-compiler 0.9.0.dev10__tar.gz → 0.9.0.dev12__tar.gz

{context_compiler-0.9.0.dev10 → context_compiler-0.9.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: context-compiler
-Version: 0.9.0.dev10
+Version: 0.9.0.dev12
 Summary: Deterministic conversational state engine for LLM applications.
 Project-URL: Homepage, https://github.com/rlippmann/context-compiler
 Project-URL: Repository, https://github.com/rlippmann/context-compiler

{context_compiler-0.9.0.dev10 → context_compiler-0.9.0.dev12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "context-compiler"
-version = "0.9.0dev10"
+version = "0.9.0dev12"
 description = "Deterministic conversational state engine for LLM applications."
 readme = "README.md"
 requires-python = ">=3.11"

{context_compiler-0.9.0.dev10 → context_compiler-0.9.0.dev12}/src/context_compiler/engine.py

@@ -276,7 +276,12 @@ def _load_state_obj(raw: object) -> _State:
     if not isinstance(policies, dict):
         raise ValueError("Invalid state payload.")
 
+    sanitized_premise = None if premise is None else _sanitize_premise_value(premise)
+    if premise is not None and sanitized_premise == "":
+        raise ValueError("Invalid state payload.")
+
     normalized_policies: dict[str, PolicyValue] = {}
+    seen_policy_sources: dict[str, str] = {}
     for key, value in policies.items():
         if not isinstance(key, str):
             raise ValueError("Invalid state payload.")
@@ -285,10 +290,14 @@ def _load_state_obj(raw: object) -> _State:
         normalized_key = _normalize_item(key)
         if normalized_key == "":
             raise ValueError("Invalid state payload.")
+        prior_source = seen_policy_sources.get(normalized_key)
+        if prior_source is not None and prior_source != key:
+            raise ValueError("Invalid state payload.")
+        seen_policy_sources[normalized_key] = key
         normalized_policies[normalized_key] = value
 
     return {
-        STATE_PREMISE: None if premise is None else _sanitize_premise_value(premise),
+        STATE_PREMISE: sanitized_premise,
         STATE_POLICIES: dict(sorted(normalized_policies.items())),
         STATE_VERSION: SCHEMA_VERSION,
     }
@@ -303,7 +312,7 @@ def _sanitize_premise_value(value: str) -> str:
 def _normalize_item(value: str) -> str:
     normalized = unicode_normalize("NFKC", value)
     normalized = normalized.replace("’", "'").replace("`", "'")
-    normalized = normalized.lower()
+    normalized = normalized.casefold()
     normalized = re.sub(r"\s+", " ", normalized).strip()
     return normalized
 

{context_compiler-0.9.0.dev10 → context_compiler-0.9.0.dev12}/src/context_compiler/grammar.py

@@ -1,7 +1,7 @@
 """Immutable canonical grammar helpers for Context Compiler directives."""
 
 import re
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from enum import StrEnum
 from types import MappingProxyType
@@ -33,14 +33,24 @@ class DirectiveSyntaxFailure(StrEnum):
 class CanonicalDirective:
     """Represent one parsed canonical directive and its named operands.
 
-    ``text`` preserves the original accepted input text. It may retain caller
-    formatting or casing and is not canonical serialized directive text.
+    ``text`` is the canonical serialized directive text derived from ``kind``
+    and ``operands``.
     """
 
-    text: str
     kind: DirectiveKind
     operands: MappingProxyType[str, str]
 
+    def __post_init__(self) -> None:
+        normalized_kind = _normalize_directive_kind(self.kind)
+        normalized_operands = _normalize_canonical_operands(normalized_kind, self.operands)
+        object.__setattr__(self, "kind", normalized_kind)
+        object.__setattr__(self, "operands", MappingProxyType(normalized_operands))
+
+    @property
+    def text(self) -> str:
+        """Return the canonical serialized directive text."""
+        return _serialize_canonical_directive(self.kind, self.operands)
+
 
 @dataclass(frozen=True, slots=True)
 class InvalidDirectiveSyntax:
@@ -365,7 +375,6 @@ def _parse_replace_use(trimmed_text: str) -> CanonicalDirective | None:
     if normalized_payload.count(_INSTEAD_OF_DELIMITER) != 1:
         return None
     return CanonicalDirective(
-        text=trimmed_text,
         kind=DirectiveKind.REPLACE_USE,
         operands=MappingProxyType({"new_item": new_item, "old_item": old_item}),
     )
@@ -384,6 +393,74 @@ def _invalid_directive_syntax(
     )
 
 
+def _normalize_directive_kind(kind: DirectiveKind | str) -> DirectiveKind:
+    try:
+        return kind if isinstance(kind, DirectiveKind) else DirectiveKind(kind)
+    except ValueError as exc:
+        raise ValueError(f"Unsupported directive kind: {kind!r}") from exc
+
+
+def _normalize_canonical_operands(
+    kind: DirectiveKind,
+    operands: Mapping[str, str],
+) -> dict[str, str]:
+    spec = _DIRECTIVE_SPECS[kind]
+    expected_names = set(spec.operand_names)
+    actual_names = set(operands)
+    unexpected_names = actual_names - expected_names
+    missing_names = expected_names - actual_names
+    if missing_names:
+        missing = ", ".join(sorted(missing_names))
+        raise ValueError(f"Missing required operands for {kind.value}: {missing}")
+    if unexpected_names:
+        unexpected = ", ".join(sorted(unexpected_names))
+        raise ValueError(f"Unexpected operands for {kind.value}: {unexpected}")
+
+    normalized_operands: dict[str, str] = {}
+    for name in spec.operand_names:
+        raw_value = operands[name]
+        if not isinstance(raw_value, str):
+            raise ValueError(f"Operand {name!r} for {kind.value} must be a string.")
+        if not _operand_has_content(raw_value):
+            raise ValueError(f"Operand {name!r} for {kind.value} cannot be empty.")
+        normalized_operands[name] = raw_value
+
+    _validate_operand_constraints(kind, normalized_operands)
+    _validate_rendered_canonical_shape(kind, normalized_operands)
+    return normalized_operands
+
+
+def _validate_operand_constraints(kind: DirectiveKind, operands: Mapping[str, str]) -> None:
+    if kind is DirectiveKind.SET_PREMISE:
+        value = operands["value"]
+        if _operand_starts_with_token(value, "to"):
+            raise ValueError(f"Operands do not produce a canonical {kind.value} directive.")
+        return
+
+    if kind is DirectiveKind.USE_ITEM:
+        item = operands["item"]
+        normalized_item = _normalized_for_matching(item)
+        if normalized_item == "instead of" or normalized_item.startswith("instead of "):
+            raise ValueError(f"Operands do not produce a canonical {kind.value} directive.")
+        if _INSTEAD_OF_DELIMITER in normalized_item:
+            raise ValueError(f"Operands do not produce a canonical {kind.value} directive.")
+        return
+
+    if kind is DirectiveKind.REPLACE_USE:
+        new_item = operands["new_item"]
+        old_item = operands["old_item"]
+        if _INSTEAD_OF_DELIMITER in _normalized_for_matching(
+            new_item
+        ) or _INSTEAD_OF_DELIMITER in _normalized_for_matching(old_item):
+            raise ValueError(f"Operands do not produce a canonical {kind.value} directive.")
+
+
+def _validate_rendered_canonical_shape(kind: DirectiveKind, operands: Mapping[str, str]) -> None:
+    rendered = _serialize_canonical_directive(kind, MappingProxyType(dict(operands)))
+    if _contains_multiple_canonical_directives(rendered):
+        raise ValueError(f"Operands do not produce a canonical {kind.value} directive.")
+
+
 def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSyntax | None:
     """Parse one canonical directive into its semantic kind and operands.
 
@@ -405,19 +482,14 @@ def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSynta
     normalized = _normalized_for_matching(trimmed_text)
 
     if normalized == _CLEAR_PREMISE_TEXT:
-        return CanonicalDirective(
-            text=text, kind=DirectiveKind.CLEAR_PREMISE, operands=MappingProxyType({})
-        )
+        return CanonicalDirective(kind=DirectiveKind.CLEAR_PREMISE, operands=MappingProxyType({}))
     if normalized == _RESET_POLICIES_TEXT:
         return CanonicalDirective(
-            text=text,
             kind=DirectiveKind.RESET_POLICIES,
             operands=MappingProxyType({}),
         )
     if normalized == _CLEAR_STATE_TEXT:
-        return CanonicalDirective(
-            text=text, kind=DirectiveKind.CLEAR_STATE, operands=MappingProxyType({})
-        )
+        return CanonicalDirective(kind=DirectiveKind.CLEAR_STATE, operands=MappingProxyType({}))
 
     if normalized == "set premise":
         return _invalid_directive_syntax(
@@ -440,7 +512,6 @@ def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSynta
                 directive_kind=DirectiveKind.SET_PREMISE,
             )
         return CanonicalDirective(
-            text=text,
             kind=DirectiveKind.SET_PREMISE,
             operands=MappingProxyType({"value": value}),
         )
@@ -468,7 +539,6 @@ def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSynta
                 missing_operand="value",
             )
         return CanonicalDirective(
-            text=text,
             kind=DirectiveKind.CHANGE_PREMISE,
             operands=MappingProxyType({"value": value}),
         )
@@ -518,7 +588,6 @@ def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSynta
                 directive_kind=DirectiveKind.USE_ITEM,
             )
         return CanonicalDirective(
-            text=text,
             kind=DirectiveKind.USE_ITEM,
             operands=MappingProxyType({"item": item}),
         )
@@ -546,7 +615,6 @@ def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSynta
                 missing_operand="item",
             )
         return CanonicalDirective(
-            text=text,
             kind=DirectiveKind.PROHIBIT_ITEM,
             operands=MappingProxyType({"item": item}),
         )
@@ -574,7 +642,6 @@ def decompose_directive(text: str) -> CanonicalDirective | InvalidDirectiveSynta
                 missing_operand="item",
             )
         return CanonicalDirective(
-            text=text,
             kind=DirectiveKind.REMOVE_POLICY,
             operands=MappingProxyType({"item": item}),
         )
@@ -588,40 +655,23 @@ def get_directive_metadata() -> tuple[DirectiveMetadata, ...]:
     return _PUBLIC_DIRECTIVE_METADATA
 
 
-def _render_directive(kind: DirectiveKind | str, /, **operands: str) -> str:
-    """Produce canonical directive text from a semantic kind and operands."""
-    try:
-        normalized_kind = kind if isinstance(kind, DirectiveKind) else DirectiveKind(kind)
-        spec = _DIRECTIVE_SPECS[normalized_kind]
-    except (KeyError, ValueError) as exc:
-        raise ValueError(f"Unsupported directive kind: {kind!r}") from exc
+def _serialize_canonical_directive(
+    kind: DirectiveKind | str, operands: MappingProxyType[str, str]
+) -> str:
+    """Serialize a validated semantic directive without reparsing it."""
+    normalized_kind = _normalize_directive_kind(kind)
+    spec = _DIRECTIVE_SPECS[normalized_kind]
 
-    expected_names = set(spec.operand_names)
-    actual_names = set(operands)
-    unexpected_names = actual_names - expected_names
-    missing_names = expected_names - actual_names
-    if missing_names:
-        missing = ", ".join(sorted(missing_names))
-        raise ValueError(f"Missing required operands for {normalized_kind.value}: {missing}")
-    if unexpected_names:
-        unexpected = ", ".join(sorted(unexpected_names))
-        raise ValueError(f"Unexpected operands for {normalized_kind.value}: {unexpected}")
+    return spec.renderer(operands)
 
-    normalized_operands: dict[str, str] = {}
-    for name in spec.operand_names:
-        raw_value = operands[name]
-        if not isinstance(raw_value, str):
-            raise ValueError(f"Operand {name!r} for {normalized_kind.value} must be a string.")
-        if raw_value.strip() == "":
-            raise ValueError(f"Operand {name!r} for {normalized_kind.value} cannot be empty.")
-        normalized_operands[name] = raw_value
 
-    operand_view = MappingProxyType(normalized_operands)
-    rendered = spec.renderer(operand_view)
-    decomposed = decompose_directive(rendered)
-    if not isinstance(decomposed, CanonicalDirective) or decomposed.kind is not normalized_kind:
-        raise ValueError(f"Operands do not produce a canonical {normalized_kind.value} directive.")
-    return rendered
+def _render_directive(kind: DirectiveKind | str, /, **operands: str) -> str:
+    """Produce canonical directive text from a semantic kind and operands."""
+    normalized_kind = _normalize_directive_kind(kind)
+    return CanonicalDirective(
+        kind=normalized_kind,
+        operands=MappingProxyType(dict(operands)),
+    ).text
 
 
 __all__ = [