engineering-argument-language 3.2.3__py3-none-any.whl

eal/knowledge.py

@@ -0,0 +1,96 @@
+"""Developer-facing EAL knowledge base and prompt adapter.
+
+The application chooses a registered entry and claim. The host selects the
+source, reuses eligible observations, runs missing collectors, evaluates the
+declared method and produces a bounded packet. A text model receives that
+packet as context, without needing EAL parsing, tool use or model reasoning.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Literal
+
+from .catalogue import WorkspaceKnowledgeCatalogue
+from .registered_assessment import RegisteredAssessmentHost
+from .runtime import ReasoningService
+from .model_context import CONTEXT_INSTRUCTION, ModelContextBuilder
+
+
+class EALKnowledgeBase:
+    """Compose the persistent catalogue and assessment path for an application."""
+
+    def __init__(self, workspace: str | Path, registry_path: str | Path | None = None,
+                 database_path: str | Path | None = None, *, method_registry: Any = None, limits=None):
+        self.service = ReasoningService(
+            workspace, registry_path, database_path, method_registry=method_registry, limits=limits,
+        )
+        self.catalogue = WorkspaceKnowledgeCatalogue(self.service)
+        self.host = RegisteredAssessmentHost(self.service, self.catalogue)
+
+    def register(self, path: str, *, entry_id: str | None = None,
+                 context: dict[str, Any] | None = None,
+                 claims: list[str] | tuple[str, ...] | None = None,
+                 label: str | None = None) -> dict[str, Any]:
+        return self.catalogue.register(
+            path, entry_id=entry_id, context=context, claims=claims, label=label,
+        )
+
+    def register_tree(self, directory: str = ".", *, context: dict[str, Any] | None = None,
+                      limit: int = 512) -> dict[str, Any]:
+        return self.catalogue.register_tree(directory, context=context, limit=limit)
+
+    def sources(self, *, limit: int = 50, offset: int = 0) -> list[dict[str, Any]]:
+        return self.catalogue.list(limit=limit, offset=offset)
+
+    def find(self, query: str | None = None, *, claim: str | None = None,
+             context: dict[str, Any] | None = None, path: str | None = None,
+             limit: int = 50) -> list[dict[str, Any]]:
+        return self.catalogue.find(query, claim=claim, context=context, path=path, limit=limit)
+
+    def assess(self, entry_id: str, claim: str, *, context: dict | None = None,
+               now: str | None = None,
+               reuse: Literal["compatible", "fresh"] = "compatible") -> dict[str, Any]:
+        return self.host.assess(entry_id, claim, context=context, now=now, reuse=reuse)
+
+    def history(self, entry_id: str, *, source_digest: str | None = None,
+                limit: int = 50) -> dict[str, Any]:
+        return self.host.history(entry_id, source_digest=source_digest, limit=limit)
+
+    def explain(self, assessment_id: str, claim: str | None = None) -> dict[str, Any]:
+        return self.service.explain(assessment_id, claim)
+
+
+class ModelContextAdapter:
+    """Build a checked prompt context for a model with no tool or reasoning API.
+
+    The caller selects a claim by exact ID; free-form questions do not choose
+    sources or change an assessment's status. The host's returned assessment
+    remains the authoritative result if a model paraphrases it incorrectly.
+    """
+
+    def __init__(self, knowledge: EALKnowledgeBase):
+        self.knowledge = knowledge
+
+    def prepare(self, question: str, entry_id: str, claim: str, *,
+                context: dict | None = None, now: str | None = None,
+                reuse: Literal["compatible", "fresh"] = "compatible") -> dict[str, Any]:
+        if not isinstance(question, str) or not question.strip() or len(question.encode("utf-8")) > 8192:
+            raise ValueError("question must contain one to 8192 UTF-8 bytes")
+        assessment = self.knowledge.assess(
+            entry_id, claim, context=context, now=now, reuse=reuse,
+        )
+        host_context = ModelContextBuilder().build(assessment)
+        return {
+            "schema": "EAL/model-context/2", "assessment": assessment,
+            "context": host_context,
+            "messages": [
+                {"role": "system", "content": (
+                    CONTEXT_INSTRUCTION
+                    + json.dumps(host_context, ensure_ascii=False, sort_keys=True,
+                                 separators=(",", ":"), allow_nan=False)
+                )},
+                {"role": "user", "content": question},
+            ],
+        }

eal/limits.py

@@ -0,0 +1,88 @@
+"""Host-owned resource budgets, independent of source-language expressiveness."""
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import asdict, dataclass, fields
+from functools import wraps
+from pathlib import Path
+import tomllib
+
+
+@dataclass(frozen=True)
+class ExecutionLimits:
+    source_bytes: int = 1024 * 1024
+    source_tokens: int = 100_000
+    structural_values: int = 100_000
+    declarations: int = 4096
+    premise_depth: int = 128
+    expansion_depth: int = 128
+    applications: int = 1000
+    expanded_references: int = 100_000
+    expression_nodes: int = 10_000
+    expression_depth: int = 128
+    json_depth: int = 64
+    json_nodes: int = 100_000
+    record_bytes: int = 4 * 1024 * 1024
+    collection_evidence: int = 128
+    composed_edges: int = 131_072
+    abstract_attacks: int = 65_536
+    formal_premises: int = 64
+    formal_rules: int = 64
+    formal_antecedents: int = 8
+    formal_atoms: int = 128
+    formal_contraries: int = 128
+    formal_arguments: int = 128
+    formal_defeats: int = 4096
+    formal_construction: int = 100_000
+    extension_search: int = 100_000
+
+    def __post_init__(self):
+        for field in fields(self):
+            value = getattr(self, field.name)
+            if type(value) is not int or value < 1:
+                raise ValueError(f"Budget {field.name} must be a positive integer")
+
+    def describe(self):
+        return asdict(self)
+
+    @classmethod
+    def load(cls, path: str | Path):
+        with Path(path).open("rb") as source:
+            supplied = tomllib.load(source)
+        if set(supplied) != {"limits"} or type(supplied["limits"]) is not dict:
+            raise ValueError("Budget file must contain exactly a [limits] table")
+        return cls(**supplied["limits"])
+
+
+_ACTIVE = ContextVar("eal_execution_limits", default=ExecutionLimits())
+
+
+def current_limits() -> ExecutionLimits:
+    return _ACTIVE.get()
+
+
+@contextmanager
+def using_limits(limits: ExecutionLimits):
+    if type(limits) is not ExecutionLimits:
+        raise TypeError("Host budgets require ExecutionLimits")
+    token = _ACTIVE.set(limits)
+    try:
+        yield
+    finally:
+        _ACTIVE.reset(token)
+
+
+def bounded(function):
+    """Carry a parsed programme's captured host budget across pure passes."""
+    @wraps(function)
+    def run(program, *args, **kwargs):
+        limits = kwargs.get('limits') or next((getattr(value, "limits", None) for value in (program, *args)
+                       if type(getattr(value, "limits", None)) is ExecutionLimits), None)
+        with using_limits(limits if type(limits) is ExecutionLimits else current_limits()):
+            return function(program, *args, **kwargs)
+    return run
+
+
+class BudgetExceeded(ValueError):
+    """An operation is incomplete; exhaustion supplies no logical conclusion."""

eal/mcp_guard.py

@@ -0,0 +1,56 @@
+"""Enforce MCP schemas, admission limits and workspace acquisition exclusion."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from functools import wraps
+from pathlib import Path
+from typing import Any
+
+import anyio
+from fastmcp.exceptions import ToolError
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+from jsonschema import Draft202012Validator
+
+from .operation_contracts import ACQUISITION_OPERATIONS
+from .acquisition_coordination import WorkspaceAcquisition
+
+
+class OperationGuard(Middleware):
+    """Bound active calls and validate schemas before framework coercion."""
+
+    def __init__(self, schemas: dict[str, dict[str, Any]], *, max_in_flight: int = 1):
+        if type(max_in_flight) is not int or not 1 <= max_in_flight <= 1024:
+            raise ValueError("max_in_flight must be an integer from 1 through 1024")
+        self._validators = {name: Draft202012Validator(schema) for name, schema in schemas.items()}
+        self._slots = anyio.Semaphore(max_in_flight)
+
+    async def on_call_tool(self, context: MiddlewareContext, call_next):
+        validator = self._validators.get(context.message.name)
+        if validator is not None:
+            errors = validator.iter_errors(context.message.arguments or {})
+            error = next(errors, None)
+            if error is not None:
+                raise ToolError("Tool input schema rejected request: " + error.message)
+        async with self._slots:
+            return await call_next(context)
+
+
+def guard_acquisition(name: str, handler: Callable[..., dict[str, Any]],
+                      workspace: Path) -> Callable[..., dict[str, Any]]:
+    """Serialise complete acquisition operations across local server processes.
+
+    Locking precedes registered-observation reuse, so a waiting assessment can
+    reuse the preceding assessment's newly acquired observation. Independent
+    collectors inside one operation still use the existing bounded scheduler.
+    """
+    if name not in ACQUISITION_OPERATIONS:
+        return handler
+    coordinator = WorkspaceAcquisition(workspace)
+
+    @wraps(handler)
+    def guarded(*args, **kwargs):
+        with coordinator.hold():
+            return handler(*args, **kwargs)
+
+    return guarded