codepot-gen 0.1.0__py3-none-any.whl

app/__init__.py

@@ -0,0 +1,9 @@
+"""Application orchestration package.
+
+This package exposes the public GeneratorApp API and app workflows used by CLI,
+tests, UI adapters, or other external interfaces.
+"""
+
+from .app import GeneratorApp
+
+__all__ = ["GeneratorApp"]

app/app.py

@@ -0,0 +1,77 @@
+"""Public runtime application API."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from app.models import (
+    EmitInput,
+    EmitOutput,
+    InferInput,
+    InferOutput,
+    InspectInput,
+    InspectOutput,
+    ValidateInput,
+    ValidateOutput,
+)
+from app.workflows.emit import run_emit
+from app.workflows.infer import run_infer
+from app.workflows.inspect import run_inspect
+from app.workflows.validate import run_validate
+
+
+class GeneratorApp:
+    """Public runtime API for the generator.
+
+    Interfaces such as CLI, UI, tests, or HTTP handlers should call this class.
+    Runtime methods return structured results and do not render terminal output.
+    """
+
+    def inspect(self, input_path: Path) -> InspectOutput:
+        """Inspect an OpenAPI document."""
+        return run_inspect(
+            InspectInput(
+                input_path=input_path,
+            )
+        )
+
+    def infer(
+        self,
+        input_path: Path,
+        output_path: Path | None = None,
+    ) -> InferOutput:
+        """Run OpenAPI inference."""
+        return run_infer(
+            InferInput(
+                input_path=input_path,
+                output_path=output_path,
+            )
+        )
+
+    def emit(
+        self,
+        input_path: Path,
+        language: str,
+        output_path: Path,
+        *,
+        dry_run: bool = False,
+        templates_path: Path | None = None,
+    ) -> EmitOutput:
+        """Emit generated output for a language."""
+        return run_emit(
+            EmitInput(
+                input_path=input_path,
+                language=language,
+                output_path=output_path,
+                dry_run=dry_run,
+                templates_path=templates_path,
+            )
+        )
+
+    def validate(self, input_path: Path) -> ValidateOutput:
+        """Validate an OpenAPI document."""
+        return run_validate(
+            ValidateInput(
+                input_path=input_path,
+            )
+        )

app/io/__init__.py

@@ -0,0 +1,5 @@
+"""Runtime file I/O helpers.
+
+This package contains serialization and file-writing helpers used by runtime
+workflows. It must not render terminal output or import CLI presentation code.
+"""

app/io/inference_output.py

@@ -0,0 +1,20 @@
+"""Inference graph output serialization."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from constants.files import ENCODING_UTF8
+from inference.models import InferenceGraph
+from inference.serialization import inference_graph_to_dict
+
+
+def write_inference_graph(graph: InferenceGraph, output_path: Path) -> Path:
+    """Write an inference graph as JSON and return the written path."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(
+        json.dumps(inference_graph_to_dict(graph), indent=2, default=str),
+        encoding=ENCODING_UTF8,
+    )
+    return output_path

app/models/__init__.py

@@ -0,0 +1,35 @@
+"""Runtime input and output contracts.
+
+These models define the public runtime interface used by CLI, tests, UI, API
+servers, and other adapters.
+"""
+
+from app.models.diagnostics import RuntimeDiagnostic
+from app.models.events import ProgressSink, RuntimeEvent
+from app.models.inputs import EmitInput, InferInput, InspectInput, ValidateInput
+from app.models.outputs import (
+    AliasSchemaSummary,
+    EmitOutput,
+    InferOutput,
+    InspectOutput,
+    ResourceSummary,
+    UnknownSchemaSummary,
+    ValidateOutput,
+)
+
+__all__ = [
+    "EmitInput",
+    "InferInput",
+    "InspectInput",
+    "ValidateInput",
+    "EmitOutput",
+    "InferOutput",
+    "InspectOutput",
+    "ValidateOutput",
+    "ResourceSummary",
+    "UnknownSchemaSummary",
+    "AliasSchemaSummary",
+    "RuntimeDiagnostic",
+    "RuntimeEvent",
+    "ProgressSink",
+]

app/models/diagnostics.py

@@ -0,0 +1,15 @@
+"""Runtime diagnostic models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class RuntimeDiagnostic:
+    """A structured diagnostic emitted by runtime workflows."""
+
+    level: str
+    message: str
+    details: dict[str, Any] = field(default_factory=dict)

app/models/events.py

@@ -0,0 +1,22 @@
+"""Runtime progress event models."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class RuntimeEvent:
+    """A structured runtime progress event."""
+
+    stage: str
+    message: str
+    level: str = "info"
+    current: int | None = None
+    total: int | None = None
+    details: dict[str, Any] = field(default_factory=dict)
+
+
+ProgressSink = Callable[[RuntimeEvent], None]

app/models/inputs.py

@@ -0,0 +1,45 @@
+"""Runtime input contracts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from app.models.events import ProgressSink
+
+
+@dataclass(frozen=True)
+class InspectInput:
+    """Input for inspecting an OpenAPI document."""
+
+    input_path: Path
+    progress: ProgressSink | None = None
+
+
+@dataclass(frozen=True)
+class ValidateInput:
+    """Input for validating an OpenAPI document."""
+
+    input_path: Path
+    progress: ProgressSink | None = None
+
+
+@dataclass(frozen=True)
+class InferInput:
+    """Input for OpenAPI inference."""
+
+    input_path: Path
+    output_path: Path | None = None
+    progress: ProgressSink | None = None
+
+
+@dataclass(frozen=True)
+class EmitInput:
+    """Input for emitting generated output."""
+
+    input_path: Path
+    language: str
+    output_path: Path
+    dry_run: bool = False
+    templates_path: Path | None = None
+    progress: ProgressSink | None = None

app/models/outputs.py

@@ -0,0 +1,108 @@
+"""Runtime output contracts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from app.models.diagnostics import RuntimeDiagnostic
+
+
+@dataclass(frozen=True)
+class ResourceSummary:
+    """Detected resource summary."""
+
+    name: str
+    path: str = "-"
+    operations_count: int = 0
+
+
+@dataclass(frozen=True)
+class UnknownSchemaSummary:
+    """Unknown schema summary for inference diagnostics."""
+
+    name: str
+    ref: str
+    x_codegen_kind: str = "-"
+    keys: list[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class AliasSchemaSummary:
+    """Alias schema summary for inference diagnostics."""
+
+    name: str
+    kind: str
+    alias_of: str = "-"
+    resource: str = "-"
+
+
+@dataclass(frozen=True)
+class InspectOutput:
+    """Output from OpenAPI inspection."""
+
+    input_path: Path
+    title: str = "-"
+    openapi_version: str = "-"
+    api_version: str = "-"
+    paths_count: int = 0
+    operations_count: int = 0
+    schemas_count: int = 0
+    responses_count: int = 0
+    request_bodies_count: int = 0
+    parameters_count: int = 0
+    refs_count: int = 0
+    component_refs_count: int = 0
+    missing_component_refs_count: int = 0
+    resources: list[ResourceSummary] = field(default_factory=list)
+    diagnostics: list[RuntimeDiagnostic] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class ValidateOutput:
+    """Output from OpenAPI validation."""
+
+    input_path: Path
+    valid: bool
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    diagnostics: list[RuntimeDiagnostic] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class InferOutput:
+    """Output from OpenAPI inference."""
+
+    input_path: Path
+    output_path: Path | None = None
+    graph: Any | None = None
+    title: str = "-"
+    openapi_version: str = "-"
+    api_version: str = "-"
+    resources_count: int = 0
+    schemas_count: int = 0
+    operations_count: int = 0
+    dependencies_count: int = 0
+    alias_schemas_count: int = 0
+    schema_kind_counts: dict[str, int] = field(default_factory=dict)
+    unknown_schemas: list[UnknownSchemaSummary] = field(default_factory=list)
+    alias_schemas: list[AliasSchemaSummary] = field(default_factory=list)
+    written: list[Path] = field(default_factory=list)
+    diagnostics: list[RuntimeDiagnostic] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class EmitOutput:
+    """Output from code/text emission."""
+
+    input_path: Path
+    language: str
+    output_path: Path
+    dry_run: bool = False
+    planned: list[Path] = field(default_factory=list)
+    written: list[Path] = field(default_factory=list)
+    updated: list[Path] = field(default_factory=list)
+    unchanged: list[Path] = field(default_factory=list)
+    skipped: list[Path] = field(default_factory=list)
+    diagnostics: list[RuntimeDiagnostic] = field(default_factory=list)

app/workflows/__init__.py

@@ -0,0 +1,7 @@
+"""
+Command workflow orchestration package.
+
+This package contains workflow functions that orchestrate the full pipeline for
+each CLI command: inspect, infer, emit, and validate. Each workflow loads documents,
+runs inference, creates emission plans, and delegates to presenters for output.
+"""

app/workflows/emit.py

@@ -0,0 +1,143 @@
+"""App emit workflow.
+
+Orchestrates the full emission pipeline: OpenAPI loading, inference, contract
+building, language adaptation, and template emission.
+"""
+
+from __future__ import annotations
+
+from app.models import EmitInput, EmitOutput, RuntimeDiagnostic, RuntimeEvent
+from app.workflows.template_paths import resolve_template_root
+from emission.engine import emit as run_emission
+from inference.contract import build_api_contract
+from inference.engine import InferenceEngine
+from languages.discovery import resolve_language_adapter
+from openapi.loader import load_openapi_document
+
+
+def run_emit(request: EmitInput) -> EmitOutput:
+    """Run the emit workflow and return structured output."""
+    _notify(
+        request,
+        stage="loading_openapi",
+        message=f"Loading OpenAPI document from {request.input_path}",
+    )
+    document = load_openapi_document(request.input_path)
+
+    _notify(
+        request,
+        stage="running_inference",
+        message="Running OpenAPI inference",
+    )
+    graph = InferenceEngine().infer(document)
+
+    _notify(
+        request,
+        stage="building_contract",
+        message="Building API contract",
+    )
+    api_contract = build_api_contract(graph)
+
+    _notify(
+        request,
+        stage="resolving_language",
+        message=f"Resolving language adapter: {request.language}",
+    )
+    adapter = resolve_language_adapter(request.language)
+    template_root = resolve_template_root(
+        adapter=adapter,
+        templates_path=request.templates_path,
+    )
+
+    _notify(
+        request,
+        stage="building_template_contract",
+        message=f"Building template contract from {template_root}",
+    )
+    template_contract = adapter.build_template_contract(
+        api=api_contract,
+        output_path=request.output_path,
+        template_root=template_root,
+        dry_run=request.dry_run,
+        progress=request.progress,
+    )
+
+    _notify(
+        request,
+        stage="emitting_files",
+        message="Emitting files",
+    )
+    emission_result = run_emission(
+        template_contract,
+        progress=request.progress,
+    )
+
+    _notify(
+        request,
+        stage="language_post_actions",
+        message="Running language post-actions",
+    )
+    post_result = adapter.after_emit(
+        result=emission_result,
+        progress=request.progress,
+    )
+
+    _notify(
+        request,
+        stage="emission_complete",
+        message="Emission completed",
+        total=len(emission_result.plan.files),
+    )
+
+    write_result = emission_result.write_result
+    diagnostics = [
+        RuntimeDiagnostic(
+            level="info",
+            message=(
+                "Emission completed: "
+                f"{len(write_result.created)} created, "
+                f"{len(write_result.updated)} updated, "
+                f"{len(write_result.unchanged)} unchanged, "
+                f"{len(write_result.skipped)} skipped."
+            ),
+        )
+    ]
+
+    diagnostics.extend(RuntimeDiagnostic(level="info", message=message) for message in post_result.diagnostics)  # noqa: E501
+
+    return EmitOutput(
+        input_path=request.input_path,
+        language=request.language,
+        output_path=request.output_path,
+        dry_run=request.dry_run,
+        planned=[file.output_path for file in emission_result.plan.files],
+        written=list(write_result.created),
+        updated=list(write_result.updated),
+        unchanged=list(write_result.unchanged),
+        skipped=list(write_result.skipped),
+        diagnostics=diagnostics,
+    )
+
+
+def _notify(
+    request: EmitInput,
+    *,
+    stage: str,
+    message: str,
+    level: str = "info",
+    current: int | None = None,
+    total: int | None = None,
+) -> None:
+    """Emit a runtime progress event when a sink is provided."""
+    if request.progress is None:
+        return
+
+    request.progress(
+        RuntimeEvent(
+            stage=stage,
+            message=message,
+            level=level,
+            current=current,
+            total=total,
+        )
+    )

app/workflows/infer.py

@@ -0,0 +1,102 @@
+"""Runtime inference workflow."""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from inference.engine import InferenceEngine
+from openapi.loader import load_openapi_document
+from app.io.inference_output import write_inference_graph
+from app.models import (
+    AliasSchemaSummary,
+    InferInput,
+    InferOutput,
+    RuntimeDiagnostic,
+    RuntimeEvent,
+    UnknownSchemaSummary,
+)
+
+
+def run_infer(request: InferInput) -> InferOutput:
+    """Run inference and return structured output."""
+    _notify(request, stage="loading_openapi", message="Loading OpenAPI document")
+    document = load_openapi_document(request.input_path)
+
+    _notify(request, stage="running_inference", message="Running inference engine")
+    graph = InferenceEngine().infer(document)
+
+    written = []
+    if request.output_path is not None:
+        _notify(
+            request,
+            stage="writing_inference_output",
+            message=f"Writing inference graph to {request.output_path}",
+        )
+        written.append(write_inference_graph(graph, request.output_path))
+
+    schemas = list(getattr(graph, "schemas", []) or [])
+    alias_schemas = [schema for schema in schemas if bool(getattr(schema, "is_alias", False))]
+    unknown_schemas = [schema for schema in schemas if getattr(getattr(schema, "kind", None), "value", "") == "unknown"]
+    kind_counts = Counter(str(getattr(getattr(schema, "kind", None), "value", "-")) for schema in schemas)
+
+    _notify(request, stage="inference_complete", message="Inference completed")
+
+    return InferOutput(
+        input_path=request.input_path,
+        output_path=request.output_path,
+        graph=graph,
+        title=str(getattr(graph, "title", "-")),
+        openapi_version=str(getattr(graph, "openapi_version", "-")),
+        api_version=str(getattr(graph, "api_version", "-")),
+        resources_count=len(list(getattr(graph, "resources", []) or [])),
+        schemas_count=len(schemas),
+        operations_count=len(list(getattr(graph, "operations", []) or [])),
+        dependencies_count=len(list(getattr(graph, "dependencies", []) or [])),
+        alias_schemas_count=len(alias_schemas),
+        schema_kind_counts=dict(sorted(kind_counts.items())),
+        unknown_schemas=[
+            UnknownSchemaSummary(
+                name=str(getattr(schema, "name", "-")),
+                ref=str(getattr(schema, "ref", "-")),
+                x_codegen_kind=str(
+                    getattr(schema, "x_codegen", {}).get("kind", "-") if isinstance(getattr(schema, "x_codegen", {}), dict) else "-"
+                ),
+                keys=sorted(list(getattr(schema, "raw", {}).keys())) if isinstance(getattr(schema, "raw", {}), dict) else [],
+            )
+            for schema in unknown_schemas
+        ],
+        alias_schemas=[
+            AliasSchemaSummary(
+                name=str(getattr(schema, "name", "-")),
+                kind=str(getattr(getattr(schema, "kind", None), "value", "-")),
+                alias_of=str(getattr(schema, "alias_of", None) or "-"),
+                resource=str(getattr(getattr(schema, "resource", None), "name", "-")),
+            )
+            for schema in alias_schemas
+        ],
+        written=written,
+        diagnostics=[RuntimeDiagnostic(level="info", message="Inference completed.")],
+    )
+
+
+def _notify(
+    request: InferInput,
+    *,
+    stage: str,
+    message: str,
+    level: str = "info",
+    current: int | None = None,
+    total: int | None = None,
+) -> None:
+    if request.progress is None:
+        return
+
+    request.progress(
+        RuntimeEvent(
+            stage=stage,
+            message=message,
+            level=level,
+            current=current,
+            total=total,
+        )
+    )

app/workflows/inspect.py

@@ -0,0 +1,99 @@
+"""Runtime OpenAPI inspection workflow."""
+
+from __future__ import annotations
+
+from openapi.inspector import inspect_openapi_document
+from openapi.loader import load_openapi_document
+from app.models import InspectInput, InspectOutput, ResourceSummary, RuntimeDiagnostic, RuntimeEvent
+
+
+def run_inspect(request: InspectInput) -> InspectOutput:
+    """Inspect an OpenAPI document and return structured output."""
+    _notify(request, stage="loading_openapi", message="Loading OpenAPI document")
+    document = load_openapi_document(request.input_path)
+
+    _notify(request, stage="inspecting_openapi", message="Inspecting OpenAPI document")
+    inspection = inspect_openapi_document(document)
+
+    _notify(request, stage="inspection_complete", message="OpenAPI inspection completed")
+
+    return InspectOutput(
+        input_path=request.input_path,
+        title=str(_value(inspection, "title")),
+        openapi_version=str(_value(inspection, "openapi_version")),
+        api_version=str(_value(inspection, "api_version")),
+        paths_count=_int_value(inspection, "path_count", "paths_count"),
+        operations_count=_int_value(inspection, "operation_count", "operations_count"),
+        schemas_count=_int_value(inspection, "schema_count", "schemas_count"),
+        responses_count=_int_value(inspection, "response_count", "responses_count"),
+        request_bodies_count=_int_value(
+            inspection,
+            "request_body_count",
+            "request_bodies_count",
+        ),
+        parameters_count=_int_value(inspection, "parameter_count", "parameters_count"),
+        refs_count=_int_value(inspection, "ref_count", "refs_count"),
+        component_refs_count=_int_value(
+            inspection,
+            "component_ref_count",
+            "component_refs_count",
+        ),
+        missing_component_refs_count=_int_value(
+            inspection,
+            "missing_component_ref_count",
+            "missing_component_refs_count",
+        ),
+        resources=[
+            ResourceSummary(
+                name=str(_value(resource, "name")),
+                path="/".join(_value(resource, "path", default=[])) or "-",
+                operations_count=_int_value(resource, "operation_count", "operations_count"),
+            )
+            for resource in _items(inspection, "resources")
+        ],
+        diagnostics=[RuntimeDiagnostic(level="info", message="OpenAPI inspection completed.")],
+    )
+
+
+def _items(value, name: str) -> list:
+    result = getattr(value, name, [])
+    return list(result or [])
+
+
+def _value(value, *names: str, default="-"):
+    for name in names:
+        if hasattr(value, name):
+            result = getattr(value, name)
+            return default if result is None else result
+    return default
+
+
+def _int_value(value, *names: str) -> int:
+    result = _value(value, *names, default=0)
+    try:
+        return int(result)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _notify(
+    request: InspectInput,
+    *,
+    stage: str,
+    message: str,
+    level: str = "info",
+    current: int | None = None,
+    total: int | None = None,
+) -> None:
+    if request.progress is None:
+        return
+
+    request.progress(
+        RuntimeEvent(
+            stage=stage,
+            message=message,
+            level=level,
+            current=current,
+            total=total,
+        )
+    )