env2llm 0.1.1__py3-none-any.whl

env2llm/__init__.py

@@ -0,0 +1,33 @@
+"""
+env2llm — environment introspection and LLM context generation.
+
+Builds machine-readable maps of available services, artifacts, commands,
+and environment variables (default: ``environment.doql.less``).
+"""
+
+from __future__ import annotations
+
+from env2llm.bootstrap import ensure_environment_map, project_artifact_root
+from env2llm.env import collect_environment, mask_secret, merge_environment
+from env2llm.formats import render_format, SUPPORTED_FORMATS
+from env2llm.generate import generate_system_map
+from env2llm.ir import SystemMapIR
+from env2llm.layout import resolve_registry_path, write_registry
+from env2llm.registry import refresh_doql_registry
+
+__all__ = [
+    "SystemMapIR",
+    "SUPPORTED_FORMATS",
+    "collect_environment",
+    "ensure_environment_map",
+    "generate_system_map",
+    "mask_secret",
+    "merge_environment",
+    "project_artifact_root",
+    "refresh_doql_registry",
+    "render_format",
+    "resolve_registry_path",
+    "write_registry",
+]
+
+__version__ = "0.1.1"

env2llm/__main__.py

@@ -0,0 +1,3 @@
+from env2llm.cli import main
+
+raise SystemExit(main())

env2llm/_runtime_health.py

@@ -0,0 +1,29 @@
+"""Minimal runtime routing helpers (no HTTP health probes)."""
+
+from __future__ import annotations
+
+_WORKER_ACTIONS = frozenset(
+    {
+        "send_invoice",
+        "generate_invoice",
+        "send_email",
+        "generate_report",
+        "crm_update",
+        "notify_slack",
+        "notify_telegram",
+        "notify_teams",
+        "generate_code",
+    }
+)
+
+
+def runtime_id_for_intent(intent: str | None) -> str | None:
+    if not intent:
+        return None
+    if intent.startswith("mullm_"):
+        return "delegate:mullm"
+    if intent.startswith("system_"):
+        return "orchestrator:nlp-service"
+    if intent in _WORKER_ACTIONS:
+        return "executor:worker"
+    return None

env2llm/artifact_layout.py

@@ -0,0 +1 @@
+from env2llm.layout import *

env2llm/bootstrap.py

@@ -0,0 +1,84 @@
+"""Bootstrap environment map files for a project directory."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Mapping
+
+from env2llm.env import collect_environment, merge_environment
+from env2llm.formats import default_output_name, render_format
+from env2llm.generate import generate_system_map
+from env2llm.layout import ensure_layout, write_registry
+from env2llm.policy.invoice import apply_invoice_policies
+from env2llm.policy.process import apply_process_policies
+from env2llm.registry import merge_registry_observations
+
+
+def project_artifact_root(project_dir: Path | str) -> Path:
+    return Path(project_dir).resolve() / ".nlp2dsl"
+
+
+def ensure_environment_map(
+    project_dir: Path | str,
+    *,
+    project_id: str | None = None,
+    output_format: str = "doql.less",
+    environment: Mapping[str, str] | None = None,
+    client: Any | None = None,
+    merge_existing: bool = True,
+    attachment: bool | None = None,
+    auto_execute: bool | None = None,
+) -> Path:
+    """
+    Generate and write the environment map for LLM/orchestrator context.
+
+    Default output: ``.nlp2dsl/registry/environment.doql.less``.
+    Other formats: yaml, json, markdown (see ``env2llm.formats``).
+    """
+    root = Path(project_dir).resolve()
+    project = project_id or root.name
+    artifact_root = project_artifact_root(root)
+    ensure_layout(artifact_root)
+
+    env = merge_environment(collect_environment(), environment)
+    ir = generate_system_map(
+        root,
+        example_id=project,
+        environment=env,
+        client=client,
+    )
+
+    if auto_execute is None:
+        auto_execute = os.environ.get("NLP2DSL_AUTO_EXECUTE", "1").strip().lower() in (
+            "1",
+            "true",
+            "yes",
+        )
+    if auto_execute:
+        ir.conversation.sync_auto_execute = True
+
+    registry_path = artifact_root / "registry" / "environment.doql.less"
+    if merge_existing and registry_path.is_file():
+        merge_registry_observations(ir, registry_path)
+
+    repo_root = root.parent.parent if root.parent.name == "examples" else root.parent
+    apply_process_policies(ir, example_id=project, repo_root=repo_root)
+    apply_invoice_policies(ir, example_id=project, attachment=attachment)
+
+    content = render_format(ir, output_format)
+    out_name = default_output_name(output_format)
+    if out_name == "environment.doql.less":
+        path = write_registry(artifact_root, content)
+    else:
+        out_dir = artifact_root / "registry"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        path = out_dir / out_name
+        path.write_text(content, encoding="utf-8")
+        mirror = artifact_root / out_name
+        if mirror != path:
+            mirror.write_text(content, encoding="utf-8")
+
+    os.environ.setdefault("ENV2LLM_CONTEXT", str(path))
+    os.environ.setdefault("NLP2DSL_DOQL_CONTEXT", str(path))
+    return path

env2llm/bridge.py

@@ -0,0 +1,225 @@
+"""Bridge: static DoqlTaskContext (today) ↔ SystemMapIR (target)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from env2llm.doql import DoqlArtifact, DoqlCommand, DoqlTaskContext, load_doql_context
+from env2llm.ir import (
+    AccessGrantIR,
+    ArtifactSpecIR,
+    CommandSchemaIR,
+    ConversationPolicyIR,
+    FieldSpec,
+    MimeTypeSpec,
+    ProcessAccessScopeIR,
+    ProcessPathsIR,
+    ProcessPolicyIR,
+    ProtocolSpec,
+    ResourceSpecIR,
+    RuntimeSpecIR,
+    SystemMapIR,
+)
+from env2llm.runtimes import build_runtimes_for_example, load_example_profile, resolve_command_runtime
+from env2llm.policy.process import apply_process_policies
+
+# Bootstrap field schemas when services.yaml omits required/optional
+_COMMAND_FIELDS: dict[str, tuple[list[str], list[str]]] = {
+    "send_invoice": (["amount", "to"], ["currency", "attachment_path"]),
+    "generate_invoice": (["amount", "to"], ["currency", "output_path"]),
+    "send_email": (["to"], ["subject", "body"]),
+    "generate_report": (["report_type"], ["format"]),
+    "crm_update": (["record_id"], ["fields"]),
+}
+
+
+def _mime_for_artifact(art: DoqlArtifact) -> MimeTypeSpec | None:
+    path = art.path.lower()
+    if path.endswith(".pdf"):
+        return MimeTypeSpec(type="application/pdf", schema_ref="InvoiceDocument")
+    if path.endswith(".json"):
+        return MimeTypeSpec(type="application/json")
+    if path.endswith(".txt"):
+        return MimeTypeSpec(type="text/plain", schema_ref="InvoiceMetadata")
+    return None
+
+
+def _process_from_ctx(ctx) -> ProcessPolicyIR:
+    proc = getattr(ctx, "process", None)
+    if proc is None:
+        return ProcessPolicyIR()
+    if isinstance(proc, ProcessPolicyIR):
+        return proc
+    return ProcessPolicyIR(
+        mode=getattr(proc, "mode", "balanced"),
+        nlp_parser=getattr(proc, "nlp_parser", "auto"),
+        nlp_confidence_min=float(getattr(proc, "nlp_confidence_min", 0.5)),
+        nlp_enrich_missing=bool(getattr(proc, "nlp_enrich_missing", False)),
+        llm_reasoning=getattr(proc, "llm_reasoning", "shallow"),
+        llm_temperature=getattr(proc, "llm_temperature", None),
+        autonomous_enabled=bool(getattr(proc, "autonomous_enabled", True)),
+        autonomous_max_rounds=int(getattr(proc, "autonomous_max_rounds", 8)),
+        ask_user=getattr(proc, "ask_user", "when_exhausted"),
+        intract_gate=bool(getattr(proc, "intract_gate", False)),
+        intract_enforce_clarification=bool(getattr(proc, "intract_enforce_clarification", False)),
+        access=ProcessAccessScopeIR(
+            agent=str(getattr(proc, "agent", "") or getattr(getattr(proc, "access", None), "agent", "")),
+            allow_resource_areas=list(
+                getattr(proc, "allow_resource_areas", None)
+                or getattr(getattr(proc, "access", None), "allow_resource_areas", [])
+                or []
+            ),
+            deny_resource_areas=list(
+                getattr(proc, "deny_resource_areas", None)
+                or getattr(getattr(proc, "access", None), "deny_resource_areas", [])
+                or []
+            ),
+        ),
+        paths=ProcessPathsIR(
+            read=list(getattr(proc, "paths_read", None) or getattr(getattr(proc, "paths", None), "read", []) or []),
+            write=list(getattr(proc, "paths_write", None) or getattr(getattr(proc, "paths", None), "write", []) or []),
+        ),
+    )
+
+
+def task_context_to_system_map(ctx: DoqlTaskContext, *, example_dir: Path | str | None = None) -> SystemMapIR:
+    """Convert hardcoded/bootstrap context into SystemMapIR (migration helper)."""
+    profile = None
+    if example_dir is not None:
+        root = Path(example_dir).resolve()
+        repo_root = root.parent.parent if root.parent.name == "examples" else root.parent
+        profile = load_example_profile(ctx.example_name, repo_root)
+
+    commands: list[CommandSchemaIR] = []
+    for cmd in ctx.commands or []:
+        commands.append(_command_to_ir(cmd, profile=profile))
+    if not commands and ctx.capabilities:
+        for name in ctx.capabilities:
+            commands.append(
+                CommandSchemaIR(
+                    name=name,
+                    runtime=resolve_command_runtime(name, profile=profile),
+                    protocol=ProtocolSpec(name="workflow/run", transport="backend→worker"),
+                )
+            )
+
+    runtimes: list[RuntimeSpecIR] = []
+    if ctx.runtimes:
+        runtimes = [
+            RuntimeSpecIR(
+                id=r.id,
+                kind=r.kind if r.kind in (
+                    "orchestrator", "gateway", "worker", "llm", "database", "cache", "mock", "external"
+                ) else "worker",
+                url=r.url or None,
+                uri=r.uri or None,
+                health=r.health or None,
+                docker_profile=r.docker_profile or None,
+                model=r.model or None,
+                roles=list(r.roles),
+                status=r.status if r.status in ("available", "unavailable", "unknown") else "unknown",
+            )
+            for r in ctx.runtimes
+        ]
+    elif example_dir is not None:
+        runtimes = build_runtimes_for_example(
+            ctx.example_name,
+            example_dir=example_dir,
+            environment=ctx.environment,
+        )
+
+    ir = SystemMapIR(
+        example_id=ctx.example_name,
+        environment=dict(ctx.environment),
+        data=dict(ctx.data),
+        runtimes=runtimes,
+        commands=commands,
+        resources=[
+            ResourceSpecIR(
+                id=r.id,
+                title=r.title,
+                connector=r.connector,
+                uri_patterns=list(r.uri_patterns),
+            )
+            for r in ctx.resources
+        ],
+        access=[
+            AccessGrantIR(
+                agent=a.agent,
+                resource_area=a.resource_area,
+                actions=list(a.actions),
+                effect=a.effect if a.effect in ("allow", "deny", "approval") else "allow",
+            )
+            for a in ctx.access
+        ],
+        artifacts=[
+            ArtifactSpecIR(
+                path=a.path,
+                kind=a.kind,
+                mime=_mime_for_artifact(a),
+                values=dict(a.values),
+            )
+            for a in ctx.artifacts
+        ],
+        capabilities=list(ctx.capabilities),
+        workflow_history=dict(ctx.workflow_history),
+        conversation=ConversationPolicyIR(
+            autofill=ctx.autofill,
+            attachment_required=ctx.attachment_required,
+            generate_invoice_if_missing=ctx.generate_invoice_if_missing,
+            sync_auto_execute=ctx.sync_auto_execute,
+            strict_pdf=ctx.strict_pdf,
+        ),
+        process=_process_from_ctx(ctx),
+        metadata={"source": "doql_context.bootstrap"},
+    )
+    if example_dir is not None:
+        root = Path(example_dir).resolve()
+        repo_root = root.parent.parent if root.parent.name == "examples" else root.parent
+        apply_process_policies(ir, example_id=ctx.example_name, repo_root=repo_root)
+    if ctx.validations:
+        ir.validations = list(ctx.validations)
+    return ir
+
+
+def _command_to_ir(cmd: DoqlCommand, *, profile: dict | None = None) -> CommandSchemaIR:
+    required = list(cmd.required)
+    optional = list(cmd.optional)
+    if not required and cmd.name in _COMMAND_FIELDS:
+        required, optional = _COMMAND_FIELDS[cmd.name]
+    fields = [
+        *[FieldSpec(name=n, required=True) for n in required],
+        *[FieldSpec(name=n, required=False) for n in optional],
+    ]
+    protocol_name = "workflow/run"
+    transport = cmd.transport
+    if cmd.transport == "nlp-service/system":
+        protocol_name = "propact:shell"
+    elif "notify" in cmd.name:
+        protocol_name = "workflow/run"
+    runtime_id = cmd.runtime or resolve_command_runtime(cmd.name, profile=profile)
+    if runtime_id == "orchestrator:nlp-service":
+        transport = "nlp-service/system"
+    elif runtime_id == "delegate:mullm":
+        transport = "nlp-service→mullm"
+    elif runtime_id == "executor:worker":
+        transport = "gateway:backend→executor:worker"
+    return CommandSchemaIR(
+        name=cmd.name,
+        description=cmd.description,
+        runtime=runtime_id,
+        protocol=ProtocolSpec(
+            name=protocol_name,
+            transport=transport,
+            endpoint=cmd.endpoint,
+        ),
+        fields=fields,
+        input_model=f"{''.join(p.title() for p in cmd.name.split('_'))}Config",
+    )
+
+
+def doql_file_to_system_map(path: Path | str) -> SystemMapIR:
+    """Parse environment.doql.less → SystemMapIR (round-trip via DoqlTaskContext)."""
+    path = Path(path)
+    ctx = load_doql_context(path)
+    return task_context_to_system_map(ctx, example_dir=path.parent.parent)

env2llm/cli.py

@@ -0,0 +1,57 @@
+"""CLI for env2llm — generate environment maps for LLM context."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from env2llm.bootstrap import ensure_environment_map
+from env2llm.formats import SUPPORTED_FORMATS, normalize_format
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="env2llm",
+        description="Generate environment maps (services, artifacts, env) for LLM decision-making.",
+    )
+    parser.add_argument(
+        "project_dir",
+        nargs="?",
+        default=".",
+        help="Project or example directory (default: cwd)",
+    )
+    parser.add_argument(
+        "--project-id",
+        default=None,
+        help="Logical project id (default: directory name)",
+    )
+    parser.add_argument(
+        "--format",
+        "-f",
+        default="doql.less",
+        help=f"Output format: {', '.join(sorted(SUPPORTED_FORMATS))}",
+    )
+    parser.add_argument(
+        "--no-merge",
+        action="store_true",
+        help="Do not merge observations from an existing registry file",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    fmt = normalize_format(args.format)
+    path = ensure_environment_map(
+        Path(args.project_dir),
+        project_id=args.project_id,
+        output_format=fmt,
+        merge_existing=not args.no_merge,
+    )
+    print(path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

env2llm/doql/__init__.py

@@ -0,0 +1,48 @@
+"""DOQL package — models, parse, render, runtime (split from doql_context)."""
+
+from .models import (
+    DoqlAccess,
+    DoqlArtifact,
+    DoqlCommand,
+    DoqlProcessPolicy,
+    DoqlResource,
+    DoqlRuntime,
+    DoqlTaskContext,
+)
+from .parse import (
+    collect_task_context,
+    enrich_task_context_from_client,
+    load_doql_context,
+    load_platform_map,
+    parse_fixture_metadata,
+)
+from .render import render_doql_context, write_doql_context
+from .runtime import (
+    autofill_entities,
+    context_inline_payload,
+    load_doql_inline_from_env,
+    merge_inline_context,
+    resolve_doql_context_path,
+)
+
+__all__ = [
+    "DoqlAccess",
+    "DoqlArtifact",
+    "DoqlCommand",
+    "DoqlProcessPolicy",
+    "DoqlResource",
+    "DoqlRuntime",
+    "DoqlTaskContext",
+    "autofill_entities",
+    "collect_task_context",
+    "context_inline_payload",
+    "enrich_task_context_from_client",
+    "load_doql_context",
+    "load_doql_inline_from_env",
+    "load_platform_map",
+    "merge_inline_context",
+    "parse_fixture_metadata",
+    "render_doql_context",
+    "resolve_doql_context_path",
+    "write_doql_context",
+]