modelable 1.0.0__py3-none-any.whl

modelable/__init__.py

@@ -0,0 +1 @@
+from modelable import _pydantic_py314_compat as _  # noqa: F401

modelable/__main__.py

@@ -0,0 +1,3 @@
+from modelable.cli import cli
+
+cli()

modelable/_pydantic_py314_compat.py

@@ -0,0 +1,31 @@
+"""
+Compatibility shim for pydantic 2.x on Python 3.14.
+
+pydantic 2.x calls typing._eval_type(..., prefer_fwd_module=True) when it
+detects Python 3.14, but Python 3.14 RC2 renamed that parameter to
+parent_fwdref. This shim patches typing._eval_type to accept both names so
+pydantic model definitions succeed without modification.
+"""
+
+from __future__ import annotations
+
+import typing
+
+_real_eval_type = typing._eval_type  # type: ignore[attr-defined]
+
+
+def _compat_eval_type(
+    t: object,
+    globalns: object = None,
+    localns: object = None,
+    type_params: object = None,
+    *,
+    prefer_fwd_module: object = None,
+    **kwargs: object,
+) -> object:
+    if prefer_fwd_module is not None:
+        kwargs.setdefault("parent_fwdref", prefer_fwd_module)
+    return _real_eval_type(t, globalns, localns, type_params=type_params, **kwargs)
+
+
+typing._eval_type = _compat_eval_type  # type: ignore[attr-defined]

modelable/cli.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import click
+
+from modelable.commands.apicurio import register_apicurio_commands
+from modelable.commands.codegen import register_codegen_commands
+from modelable.commands.compile import register_compile_commands
+from modelable.commands.create import register_create_commands
+from modelable.commands.diff import register_diff_commands
+from modelable.commands.graph import register_graph_commands
+from modelable.commands.llm import register_llm_commands
+from modelable.commands.lsp import register_lsp_commands
+from modelable.commands.runtime import register_runtime_commands
+from modelable.commands.scenario import register_scenario_commands
+from modelable.commands.spec import register_spec_commands
+from modelable.commands.workspace import register_workspace_commands
+
+
+@click.group()
+@click.version_option(package_name="modelable", prog_name="modelable")
+def cli() -> None:
+    """Modelable domain-owned data model compiler.
+
+    MVP workflows cover validate, resolve, lineage, diff, compile, docs,
+    inspect, codegen, lsp, scenario, create helpers, and Apicurio JSON Schema
+    artifact publish/pull.
+    """
+
+
+register_workspace_commands(cli)
+register_compile_commands(cli)
+register_create_commands(cli)
+register_diff_commands(cli)
+register_graph_commands(cli)
+register_lsp_commands(cli)
+register_llm_commands(cli)
+register_codegen_commands(cli)
+register_scenario_commands(cli)
+register_runtime_commands(cli)
+register_apicurio_commands(cli)
+register_spec_commands(cli)

modelable/commands/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

modelable/commands/apicurio.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import click
+
+from modelable.commands.common import console, load_workspace_or_exit
+from modelable.emitters.json_schema import emit_json_schema
+from modelable.registry.apicurio import ApicurioArtifact, ApicurioRegistryClient, ApicurioRegistryError
+
+
+def register_apicurio_commands(cli_group: click.Group) -> None:
+    cli_group.add_command(publish)
+    cli_group.add_command(pull)
+
+
+@click.group()
+def publish() -> None:
+    """Publish generated artifacts to external registries."""
+
+
+@publish.command(name="apicurio")
+@click.argument("source", type=click.Path(exists=True, path_type=Path))
+@click.option("--url", required=True, help="Apicurio Registry base URL or /apis/registry/v3 URL.")
+@click.option("--group", default="default", show_default=True, help="Apicurio artifact group.")
+@click.option("--token", default=None, help="Bearer token. Defaults to MODELABLE_APICURIO_TOKEN.")
+@click.option("--dry-run", is_flag=True, help="List artifacts without publishing.")
+def publish_apicurio(source: Path, url: str, group: str, token: str | None, dry_run: bool) -> None:
+    """Publish JSON Schema artifacts generated from SOURCE to Apicurio Registry."""
+    workspace = load_workspace_or_exit(source)
+    emitted = emit_json_schema(workspace, Path(".modelable/apicurio"))
+    artifacts = [
+        ApicurioArtifact(
+            artifact_id=artifact.artifact_id,
+            version=artifact.artifact_id.rsplit(".v", 1)[1],
+            content=artifact.content,
+        )
+        for artifact in emitted
+        if isinstance(artifact.content, dict)
+    ]
+
+    if dry_run:
+        console.print(f"[yellow]DRY RUN[/yellow] would publish {len(artifacts)} JSON Schema artifact(s) to {url}")
+        for artifact in artifacts:
+            console.print(f"- {artifact.artifact_id} (group={group}, version={artifact.version})")
+        sys.exit(0)
+
+    client = ApicurioRegistryClient(url, token=token or os.getenv("MODELABLE_APICURIO_TOKEN"))
+    try:
+        for artifact in artifacts:
+            client.publish_json_schema(artifact, group=group)
+            console.print(f"[green]OK[/green] published {group}/{artifact.artifact_id}@{artifact.version}")
+    except ApicurioRegistryError as exc:
+        console.print(f"[red]ERROR[/red] {exc}")
+        sys.exit(1)
+
+    if not artifacts:
+        console.print("[yellow]No JSON Schema artifacts generated.[/yellow]")
+    sys.exit(0)
+
+
+@click.group()
+def pull() -> None:
+    """Pull generated artifacts from external registries."""
+
+
+@pull.command(name="apicurio")
+@click.argument("ref")
+@click.option("--url", required=True, help="Apicurio Registry base URL or /apis/registry/v3 URL.")
+@click.option("--group", default="default", show_default=True, help="Apicurio artifact group.")
+@click.option("--out", "out_dir", type=click.Path(path_type=Path), default=Path("./dist/jsonschema"))
+@click.option("--token", default=None, help="Bearer token. Defaults to MODELABLE_APICURIO_TOKEN.")
+def pull_apicurio(ref: str, url: str, group: str, out_dir: Path, token: str | None) -> None:
+    """Pull a JSON Schema artifact by Modelable REF from Apicurio Registry."""
+    client = ApicurioRegistryClient(url, token=token or os.getenv("MODELABLE_APICURIO_TOKEN"))
+    try:
+        path = client.pull_json_schema(ref, group=group, out_dir=out_dir)
+    except ApicurioRegistryError as exc:
+        console.print(f"[red]ERROR[/red] {exc}")
+        sys.exit(1)
+    console.print(f"[green]OK[/green] wrote {path}")
+    sys.exit(0)

modelable/commands/codegen.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from modelable.emitters.shapes import type_shape_catalog
+from modelable.emitters.targets import (
+    get_codegen_target,
+    list_implemented_codegen_targets,
+)
+from modelable.emitters.targets import (
+    list_codegen_targets as _list_codegen_targets,
+)
+
+console = Console()
+
+
+def register_codegen_commands(cli_group: click.Group) -> None:
+    cli_group.add_command(codegen)
+
+
+@click.group()
+def codegen() -> None:
+    """Explore supported code generation formats and type mappings."""
+
+
+@codegen.command(name="formats")
+def formats() -> None:
+    """List supported compilation targets."""
+    console.print("Supported code generation formats:", markup=False)
+    for entry in _list_codegen_targets():
+        console.print(f"- {entry.name}: {entry.description} [{entry.status}, {entry.kind}]", markup=False)
+
+
+@codegen.command(name="types")
+@click.option(
+    "--format",
+    "format_name",
+    type=click.Choice([entry.name for entry in list_implemented_codegen_targets()]),
+    default="typescript",
+    show_default=True,
+    help="Target format to describe.",
+)
+def types(format_name: str) -> None:
+    """Show the field-type mapping for a target format."""
+    entry = get_codegen_target(format_name)
+    console.print("Target inventory:", markup=False)
+    for target in _list_codegen_targets():
+        console.print(f"- {target.name}: {target.status} [{target.kind}]", markup=False)
+    console.print("", markup=False)
+    console.print(f"{format_name} type mappings", markup=False)
+    console.print(f"{entry.description}", markup=False)
+    console.print("", markup=False)
+    console.print("Type shape catalog:", markup=False)
+    for label, shape, note in type_shape_catalog():
+        line = f"- {label}: {shape.describe()}"
+        if note:
+            line += f" ({note})"
+        console.print(line, markup=False)
+    console.print("", markup=False)
+
+    for source_type, target_type, note in _type_mappings_for(format_name):
+        line = f"- {source_type} -> {target_type}"
+        if note:
+            line += f" ({note})"
+        console.print(line, markup=False)
+
+
+def list_codegen_targets() -> list[dict[str, object]]:
+    return [
+        {
+            "name": target.name,
+            "description": target.description,
+            "status": target.status,
+            "kind": target.kind,
+            "default_out_dir": str(target.default_out_dir) if target.default_out_dir is not None else None,
+        }
+        for target in _list_codegen_targets()
+    ]
+
+
+def _type_mappings_for(format_name: str) -> list[tuple[str, str, str | None]]:
+    if format_name == "json-schema":
+        return [
+            ("string", '{"type":"string"}', None),
+            ("bool", '{"type":"boolean"}', None),
+            ("int", '{"type":"integer","format":"int64"}', None),
+            ("float", '{"type":"number"}', None),
+            ("uuid", '{"type":"string","format":"uuid"}', None),
+            ("timestamp", '{"type":"string","format":"date-time"}', None),
+            ("date", '{"type":"string","format":"date"}', None),
+            ("time", '{"type":"string","format":"time"}', None),
+            ("duration", '{"type":"string","format":"duration"}', None),
+            ("binary", '{"type":"string","contentEncoding":"base64"}', None),
+            ("decimal(p, s)", '{"type":"string","pattern":"^-?\\d+(\\.\\d+)?$"}', None),
+            ("array<T>", '{"type":"array","items":<T>}', None),
+            ("map<K, V>", '{"type":"object","additionalProperties":<V>}', None),
+            ("ref<T>", '{"type":"string","x-modelable-ref":"T"}', None),
+            ("enum(...)", '{"type":"string","enum":[...]}', None),
+            ("object { ... }", '{"type":"object","properties":{...}}', None),
+            ("named", '{"type":"object","x-modelable-field":{"namedType":"Name"}}', None),
+        ]
+    if format_name == "csharp":
+        return [
+            ("string", "string", "optional fields use string?"),
+            ("bool", "bool", "optional fields use bool?"),
+            ("int", "int", "optional fields use int?"),
+            ("float", "double", "optional fields use double?"),
+            ("uuid", "Guid", "optional fields use Guid?"),
+            ("timestamp", "DateTime", "optional fields use DateTime?"),
+            ("date", "DateOnly", "optional fields use DateOnly?"),
+            ("time", "TimeOnly", "optional fields use TimeOnly?"),
+            ("duration", "TimeSpan", "optional fields use TimeSpan?"),
+            ("binary", "byte[]", "optional fields use byte[]?"),
+            ("decimal(p, s)", "decimal", "optional fields use decimal?"),
+            ("array<T>", "List<T>", None),
+            ("map<K, V>", "Dictionary<string, V>", None),
+            ("ref<T>", "string", "references compile to reference strings"),
+            ("enum(...)", "string", None),
+            ("object { ... }", "{ ... }", "inline objects become nested records"),
+            ("named", "Name", None),
+        ]
+    if format_name == "java":
+        return [
+            ("string", "String", "optional fields use Optional<String>"),
+            ("bool", "Boolean", "optional fields use Optional<Boolean>"),
+            ("int", "Long", "optional fields use Optional<Long>"),
+            ("float", "Double", "optional fields use Optional<Double>"),
+            ("uuid", "UUID", "optional fields use Optional<UUID>"),
+            ("timestamp", "Instant", "optional fields use Optional<Instant>"),
+            ("date", "LocalDate", "optional fields use Optional<LocalDate>"),
+            ("time", "LocalTime", "optional fields use Optional<LocalTime>"),
+            ("duration", "Duration", "optional fields use Optional<Duration>"),
+            ("binary", "byte[]", "optional fields use Optional<byte[]>"),
+            ("decimal(p, s)", "BigDecimal", "optional fields use Optional<BigDecimal>"),
+            ("array<T>", "List<T>", None),
+            ("map<K, V>", "Map<String, V>", None),
+            ("ref<T>", "String", "references compile to reference strings"),
+            ("enum(...)", "String", None),
+            ("object { ... }", "{ ... }", "inline objects become nested records"),
+            ("named", "NameV1", None),
+        ]
+    if format_name == "python":
+        return [
+            ("string", "str", "optional fields use Optional[str]"),
+            ("bool", "bool", "optional fields use Optional[bool]"),
+            ("int", "int", "optional fields use Optional[int]"),
+            ("float", "float", "optional fields use Optional[float]"),
+            ("uuid", "UUID", "optional fields use Optional[UUID]"),
+            ("timestamp", "datetime", "optional fields use Optional[datetime]"),
+            ("date", "date", "optional fields use Optional[date]"),
+            ("time", "time", "optional fields use Optional[time]"),
+            ("duration", "timedelta", "optional fields use Optional[timedelta]"),
+            ("binary", "bytes", "optional fields use Optional[bytes]"),
+            ("decimal(p, s)", "Decimal", "optional fields use Optional[Decimal]"),
+            ("array<T>", "list[T]", None),
+            ("map<K, V>", "dict[str, V]", None),
+            ("ref<T>", "str", "references compile to reference strings"),
+            ("enum(...)", "str", None),
+            ("object { ... }", "{ ... }", "inline objects become nested dataclasses"),
+            ("named", "Name", None),
+        ]
+    if format_name == "rust":
+        return [
+            ("string", "String", "optional fields use Option<String>"),
+            ("bool", "bool", "optional fields use Option<bool>"),
+            ("int", "i64", "optional fields use Option<i64>"),
+            ("float", "f64", "optional fields use Option<f64>"),
+            ("uuid", "String", "optional fields use Option<String>"),
+            ("timestamp", "String", "optional fields use Option<String>"),
+            ("date", "String", "optional fields use Option<String>"),
+            ("time", "String", "optional fields use Option<String>"),
+            ("duration", "String", "optional fields use Option<String>"),
+            ("binary", "Vec<u8>", "optional fields use Option<Vec<u8>>"),
+            ("decimal(p, s)", "String", "optional fields use Option<String>"),
+            ("array<T>", "Vec<T>", None),
+            ("map<K, V>", "HashMap<String, V>", None),
+            ("ref<T>", "String", "references compile to reference strings"),
+            ("enum(...)", "String", None),
+            ("object { ... }", "{ ... }", "inline objects become nested structs"),
+            ("named", "Name", None),
+        ]
+    if format_name == "go":
+        return [
+            ("string", "string", "optional fields use *string"),
+            ("bool", "bool", "optional fields use *bool"),
+            ("int", "int64", "optional fields use *int64"),
+            ("float", "float64", "optional fields use *float64"),
+            ("uuid", "string", "optional fields use *string"),
+            ("timestamp", "time.Time", "optional fields use *time.Time"),
+            ("date", "time.Time", "optional fields use *time.Time"),
+            ("time", "time.Time", "optional fields use *time.Time"),
+            ("duration", "time.Duration", "optional fields use *time.Duration"),
+            ("binary", "[]byte", "optional fields use *[]byte"),
+            ("decimal(p, s)", "string", "optional fields use *string"),
+            ("array<T>", "[]T", None),
+            ("map<K, V>", "map[string]V", None),
+            ("ref<T>", "string", "references compile to reference strings"),
+            ("enum(...)", "string", None),
+            ("object { ... }", "{ ... }", "inline objects become nested structs"),
+            ("named", "Name", None),
+        ]
+    if format_name == "markdown":
+        return [
+            ("string", "string", "rendered as canonical .mdl text"),
+            ("bool", "bool", "rendered as canonical .mdl text"),
+            ("int", "int", "rendered as canonical .mdl text"),
+            ("float", "float", "rendered as canonical .mdl text"),
+            ("uuid", "uuid", "rendered as canonical .mdl text"),
+            ("timestamp", "timestamp", "rendered as canonical .mdl text"),
+            ("date", "date", "rendered as canonical .mdl text"),
+            ("time", "time", "rendered as canonical .mdl text"),
+            ("duration", "duration", "rendered as canonical .mdl text"),
+            ("binary", "binary", "rendered as canonical .mdl text"),
+            ("decimal(p, s)", "decimal(p, s)", "rendered as canonical .mdl text"),
+            ("array<T>", "array<T>", "rendered as canonical .mdl text"),
+            ("map<K, V>", "map<K, V>", "rendered as canonical .mdl text"),
+            ("ref<T>", "ref<T>", "rendered as canonical .mdl text"),
+            ("enum(...)", "enum(...)", "rendered as canonical .mdl text"),
+            ("object { ... }", "object { ... }", "rendered as canonical .mdl text"),
+            ("named", "Name", "rendered as canonical .mdl text"),
+        ]
+    return [
+        ("string", "string", None),
+        ("bool", "boolean", None),
+        ("int", "number", None),
+        ("float", "number", None),
+        ("uuid", "string", "preserves uuid format as a string"),
+        ("timestamp", "string", "preserves date-time semantics"),
+        ("date", "string", "preserves date semantics"),
+        ("time", "string", "preserves time semantics"),
+        ("duration", "string", "preserves duration semantics"),
+        ("binary", "string", "base64-encoded"),
+        ("decimal(p, s)", "string", "decimal precision and scale encoded as text"),
+        ("array<T>", "T[]", None),
+        ("map<K, V>", "Record<string, V>", None),
+        ("ref<T>", "string", "reference string"),
+        ("enum(...)", "'a' | 'b' | ...", None),
+        ("object { ... }", "{ ... }", None),
+        ("named", "Name", None),
+    ]

modelable/commands/common.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+from modelable.compiler.workspace import load_workspace
+from modelable.diagnostics.model import render_diagnostic
+from modelable.parser.ir import ParseError, VersionPinned
+
+console = Console()
+
+
+def load_workspace_or_exit(path: Path):
+    try:
+        workspace = load_workspace(path)
+    except FileNotFoundError:
+        console.print("[yellow]No .mdl files found.[/yellow]")
+        sys.exit(0)
+    except ParseError as exc:
+        console.print(f"[red]ERROR[/red] {render_diagnostic(exc.diagnostic(path=path))}")
+        sys.exit(1)
+
+    if workspace.errors:
+        for diagnostic in workspace.errors:
+            console.print(f"[red]ERROR[/red] {render_diagnostic(diagnostic)}", soft_wrap=True)
+        sys.exit(1)
+
+    return workspace
+
+
+def render_version_spec(version_spec) -> str:
+    kind = getattr(version_spec, "kind", None)
+    if kind == "exact":
+        return str(version_spec.version)
+    if kind == "range":
+        return f">={version_spec.min_inclusive}<{version_spec.max_exclusive}"
+    if kind == "min":
+        return f">={version_spec.min_inclusive}"
+    if isinstance(version_spec, VersionPinned):
+        return f"{version_spec.version}#{version_spec.content_hash}"
+    return "?"