core-runtime-engine 11.5.1__py3-none-any.whl

core_runtime/__init__.py

@@ -0,0 +1,10 @@
+"""CORE — deterministic contract, schema and validation engine.
+
+CORE validates artifacts against public contracts: schemas, fingerprints,
+manifests and bounded evidence. It never executes domain logic, never
+holds private semantics and never decides legal truth.
+"""
+
+from core_runtime.__version__ import __version__
+
+__all__ = ["__version__"]

core_runtime/__version__.py

@@ -0,0 +1,17 @@
+"""CORE Runtime - Single Source of Truth for Version.
+
+This file is the canonical version source. All other version references
+(pyproject.toml, core_runtime/__init__.py, documentation) should be
+kept in sync with this value.
+
+DO NOT EDIT THIS FILE MANUALLY.
+Use scripts/bump_version.py to update versions consistently.
+"""
+
+__version__ = "11.5.1"
+
+# Component versions
+CORE_VERSION = "11.5.1"
+
+# Parsed version tuple for programmatic comparison
+VERSION_INFO = tuple(int(x) for x in __version__.split("."))

core_runtime/cli/__init__.py

@@ -0,0 +1,7 @@
+"""CORE Runtime CLI - tooling commands."""
+
+from __future__ import annotations
+
+from core_runtime.__version__ import __version__
+
+__all__ = ["__version__"]

core_runtime/cli/__main__.py

@@ -0,0 +1,22 @@
+"""CLI entry point for core_runtime.tool commands."""
+
+from __future__ import annotations
+
+import sys
+
+from core_runtime.cli.main import build_parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 2
+
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

core_runtime/cli/bump_version.py

@@ -0,0 +1,176 @@
+"""CLI command for bump-version — dry-run and controlled apply."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from core_runtime.tooling.bump_version import BumpVersionPlanner
+from core_runtime.tooling.diagnostics import DiagnosticCollection, ExitCode
+from core_runtime.tooling.version_inventory import VersionInventory
+
+
+def cmd_bump_version(args: object) -> int:
+    """Execute the bump-version command (dry-run or controlled apply)."""
+    # Access args safely (argparse Namespace or test mock)
+    target_version_raw = getattr(args, "target_version", None)
+    dry_run: bool = getattr(args, "dry_run", False)
+    apply_mode: bool = getattr(args, "apply", False)
+    confirm_current: str | None = getattr(args, "confirm_current", None)
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+
+    diagnostics = DiagnosticCollection()
+
+    # ---- Mutual exclusion: --dry-run and --apply cannot both be set ----
+    if dry_run and apply_mode:
+        blocked_msg = {
+            "code": "core.bump_version.mutual_exclusion",
+            "severity": "blocked",
+            "message": "--dry-run and --apply are mutually exclusive. Specify one.",
+            "mutation_allowed": False,
+        }
+        if fmt == "json":
+            print(json.dumps(blocked_msg, indent=2, ensure_ascii=False))
+        else:
+            print("# BLOCKED")
+            print("")
+            print("--dry-run and --apply are mutually exclusive. Specify one.")
+        return ExitCode.BLOCKED.value
+
+    # ---- Default mode: if neither flag is set, default to dry-run ----
+    if not dry_run and not apply_mode:
+        dry_run = True
+
+    # ---- Apply mode: --confirm-current is required ----
+    if apply_mode and not confirm_current:
+        blocked_msg = {
+            "code": "core.bump_version.confirm_current_required",
+            "severity": "blocked",
+            "message": "--confirm-current is required when using --apply.",
+            "mutation_allowed": False,
+        }
+        if fmt == "json":
+            print(json.dumps(blocked_msg, indent=2, ensure_ascii=False))
+        else:
+            print("# BLOCKED")
+            print("")
+            print("--confirm-current is required when using --apply.")
+            print("Usage: python -m core_runtime.cli bump-version <target> --apply --confirm-current <current>")
+        return ExitCode.BLOCKED.value
+
+    # Guard against None (argparse should always provide this)
+    if target_version_raw is None:
+        print("Error: target_version is required", file=sys.stderr)
+        return ExitCode.INTERNAL_ERROR.value
+
+    target_version: str = target_version_raw
+
+    repo_root = Path(__file__).resolve().parents[2]  # core_runtime/cli/ -> repo_root
+
+    # Discover current version before planning/applying
+    version_inv = VersionInventory(repo_root)
+    current_version = version_inv.get_canonical_version()
+    if current_version is None:
+        diagnostics.add_blocked(
+            code="core.bump_version.canonical_missing",
+            message="Cannot determine current canonical version",
+            path="core_runtime/__version__.py",
+        )
+        base_report = {
+            "tool": "core-runtime bump-version",
+            "mode": "apply" if apply_mode else "dry-run",
+            "status": "blocked",
+            "mutation_performed": False,
+            "current_version": None,
+            "target_version": target_version,
+            "summary": {"files_checked": 0, "files_that_would_change": 0,
+                        "replacement_count": 0, "info": 0, "warning": 0,
+                        "error": 0, "blocked": 1},
+            "changes": [],
+            "diagnostics": [d.to_dict() for d in diagnostics.diagnostics],
+        }
+        if fmt == "json":
+            print(json.dumps(base_report, indent=2, ensure_ascii=False))
+        else:
+            print("# BLOCKED: Cannot determine current version")
+        return ExitCode.BLOCKED.value
+
+    planner = BumpVersionPlanner(repo_root)
+    output_path = Path(output) if output else None
+
+    # ================================================================
+    # DRY-RUN MODE
+    # ================================================================
+    if dry_run:
+        changes, summary = planner.plan(target_version, diagnostics)
+        if fmt == "json":
+            report = planner.report_json(
+                target_version=target_version,
+                current_version=current_version,
+                changes=changes,
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="dry-run",
+                mutation_performed=False,
+            )
+            if not output_path:
+                print(json.dumps(report, indent=2, ensure_ascii=False))
+        else:
+            md = planner.report_markdown(
+                target_version=target_version,
+                current_version=current_version,
+                changes=changes,
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="dry-run",
+                mutation_performed=False,
+            )
+            if not output_path:
+                print(md)
+        return diagnostics.compute_exit_code().value
+
+    # ================================================================
+    # APPLY MODE
+    # ================================================================
+    if apply_mode:
+        applied_changes, summary = planner.apply(
+            target_version=target_version,
+            confirm_current=confirm_current,  # type: ignore[arg-type]
+            diagnostics=diagnostics,
+        )
+        if fmt == "json":
+            report = planner.report_json(
+                target_version=target_version,
+                current_version=current_version,
+                changes=[],  # not used in apply mode
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="apply",
+                mutation_performed=(diagnostics.compute_exit_code() == ExitCode.OK),
+                applied_changes=applied_changes,
+            )
+            if not output_path:
+                print(json.dumps(report, indent=2, ensure_ascii=False))
+        else:
+            md = planner.report_markdown(
+                target_version=target_version,
+                current_version=current_version,
+                changes=[],  # not used in apply mode
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="apply",
+                mutation_performed=(diagnostics.compute_exit_code() == ExitCode.OK),
+                applied_changes=applied_changes,
+            )
+            if not output_path:
+                print(md)
+        return diagnostics.compute_exit_code().value
+
+    # Should never reach here
+    return ExitCode.INTERNAL_ERROR.value

core_runtime/cli/contract_preflight.py

@@ -0,0 +1,69 @@
+"""CLI command for `core-runtime contract-preflight`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.contract_preflight import ContractPreflightReport, RepositoryContractPreflight
+from core_runtime.tooling.diagnostics import ExitCode
+
+
+def cmd_contract_preflight(args: object) -> int:
+    """Execute the advisory-only contract preflight command."""
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    candidate = getattr(args, "candidate", None)
+    compare = getattr(args, "compare", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    preflight = RepositoryContractPreflight(repo_root)
+
+    if compare:
+        report = preflight.build_compare_report(compare[0], compare[1])
+    elif candidate:
+        report = preflight.build_candidate_report(candidate)
+    else:
+        from core_runtime.tooling.diagnostics import DiagnosticCollection
+
+        diagnostics = DiagnosticCollection()
+        diagnostics.add_blocked(
+            code="core.contract_preflight.mode_required",
+            message="contract-preflight requires --candidate or --compare",
+            path="contract-preflight",
+            expected="--candidate <name> or --compare <a> <b>",
+            actual="missing mode",
+        )
+        report = ContractPreflightReport(
+            tool="core-runtime contract-preflight",
+            command="contract-preflight",
+            status="blocked",
+            summary={"mode": "missing", "item_count": 0},
+            selection={"mode": "missing"},
+            diagnostics=diagnostics,
+        )
+
+    output_path = Path(output) if output else None
+    if fmt == "json":
+        payload = report.to_dict()
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(text + "\n", encoding="utf-8")
+        else:
+            print(text)
+    else:
+        markdown = report.to_markdown()
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(markdown, encoding="utf-8")
+        else:
+            print(markdown)
+
+    status_to_exit = {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }
+    return status_to_exit.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime/cli/create_domain.py

@@ -0,0 +1,66 @@
+"""CLI command for `core-runtime create-domain`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.create_domain import CreateDomainReport, DomainScaffolder
+from core_runtime.tooling.diagnostics import DiagnosticCollection, ExitCode
+
+
+def cmd_create_domain(args: object) -> int:
+    """Execute the dry-run-first domain scaffolding preflight."""
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    name = getattr(args, "name", None)
+    template = getattr(args, "template", "generic")
+    dry_run = bool(getattr(args, "dry_run", False))
+    repo_root = Path(__file__).resolve().parents[2]
+    scaffolder = DomainScaffolder(repo_root)
+
+    if not dry_run:
+        diagnostics = DiagnosticCollection()
+        diagnostics.add_blocked(
+            code="core.create_domain.dry_run_required",
+            message="create-domain is dry-run only in this slice",
+            path=name or "create-domain",
+            expected="--dry-run",
+            actual="missing dry-run",
+        )
+        report = CreateDomainReport(
+            tool="core-runtime create-domain",
+            command="create-domain {0}".format(name or ""),
+            status="blocked",
+            summary={"mode": "missing_dry_run", "item_count": 0},
+            selection={"domain": name, "template": template, "mode": "missing_dry_run"},
+            diagnostics=diagnostics,
+        )
+    else:
+        report = scaffolder.build_plan(name=name, template=template)
+
+    output_path = Path(output) if output else None
+    if fmt == "json":
+        payload = report.to_dict()
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(text + "\n", encoding="utf-8")
+        else:
+            print(text)
+    else:
+        markdown = report.to_markdown()
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(markdown, encoding="utf-8")
+        else:
+            print(markdown)
+
+    status_to_exit = {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }
+    return status_to_exit.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime/cli/doctor.py

@@ -0,0 +1,44 @@
+"""CLI command for `core-runtime doctor`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.diagnostics import ExitCode
+from core_runtime.tooling.doctor import RepositoryDoctor
+
+
+def cmd_doctor(args: object) -> int:
+    """Execute the doctor preflight command."""
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    doctor = RepositoryDoctor(repo_root)
+    report = doctor.build_report()
+    output_path = Path(output) if output else None
+
+    if fmt == "json":
+        payload = report.to_dict()
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(text + "\n", encoding="utf-8")
+        else:
+            print(text)
+    else:
+        markdown = report.to_markdown()
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(markdown, encoding="utf-8")
+        else:
+            print(markdown)
+
+    status_to_exit = {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }
+    return status_to_exit.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime/cli/inventory.py

@@ -0,0 +1,85 @@
+"""CLI commands for read-only repository inventory navigation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.diagnostics import ExitCode
+from core_runtime.tooling.repository_inventory import RepositoryInventory
+
+
+_KIND_ALIASES = {
+    "schema": "schemas",
+    "schemas": "schemas",
+    "contract": "contracts",
+    "contracts": "contracts",
+    "adapter": "adapters",
+    "adapters": "adapters",
+    "domain": "domains",
+    "domains": "domains",
+}
+
+
+def _normalize_kind(kind: str | None) -> str | None:
+    if kind is None:
+        return None
+    return _KIND_ALIASES.get(kind.lower())
+
+
+def _emit_report(report, fmt: str, output) -> None:
+    payload = report.to_dict()
+    if fmt == "json":
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+    else:
+        text = report.to_markdown()
+    if output:
+        output_path = Path(output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(text + ("\n" if fmt == "json" else ""), encoding="utf-8")
+    else:
+        print(text)
+
+
+def cmd_list(args: object) -> int:
+    """List repository inventory items by kind."""
+    raw_kind = getattr(args, "kind", None)
+    kind = _normalize_kind(raw_kind)
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    inventory = RepositoryInventory(repo_root)
+
+    if raw_kind is None:
+        kind = "schemas"
+    elif kind is None:
+        kind = str(raw_kind)
+
+    report = inventory.build_list_report(kind)
+    _emit_report(report, fmt, output)
+    return ExitCode.BLOCKED.value if report.status == "blocked" else ExitCode.OK.value
+
+
+def cmd_info(args: object) -> int:
+    """Show inventory summary or item details."""
+    raw_kind = getattr(args, "kind", None)
+    kind = _normalize_kind(raw_kind)
+    name = getattr(args, "name", None)
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    inventory = RepositoryInventory(repo_root)
+
+    if raw_kind is not None and kind is None:
+        kind = str(raw_kind)
+
+    report = inventory.build_info_report(kind=kind, name=name)
+    _emit_report(report, fmt, output)
+
+    return {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime/cli/lint.py

@@ -0,0 +1,8 @@
+"""CLI command for lint — thin import wrapper."""
+
+from __future__ import annotations
+
+from core_runtime.cli.main import cmd_lint
+
+__all__ = ["cmd_lint"]
+