#!/usr/bin/env python3
"""Run starter checks without a shell or package installation.
Default: real Python subprocess + shared schema/fixture tests.
--rust: also run the authored Rust tests. Missing Cargo is an ERROR, not a skip.
--format: explicitly allow rustfmt to edit only the new Rust crate.
"""
from __future__ import annotations
import argparse
import datetime
import json
import os
from pathlib import Path
import platform
import shutil
import sqlite3
import subprocess
import sys
import tempfile
import time
import tomllib
import zipfile
ROOT = Path(__file__).resolve().parents[1]
def static_contracts() -> dict:
"""Only manifest consistency, not dependency resolution or Rust compilation."""
workspace = tomllib.loads((ROOT / "Cargo.toml").read_text())
lock = tomllib.loads((ROOT / "Cargo.lock").read_text())
assert "klbr-runtime" in workspace["workspace"]["members"]
packages = lock["package"]
entry = next(p for p in packages if p["name"] == "klbr-runtime")
for dependency in entry["dependencies"]:
parts = dependency.split()
matches = [p for p in packages if p["name"] == parts[0] and
(len(parts) == 1 or p["version"] == parts[1])]
assert len(matches) == 1, f"ambiguous/missing lock entry: {dependency}"
crate = tomllib.loads((ROOT / "klbr-runtime/Cargo.toml").read_text())
assert set(crate["dependencies"]) == {d.split()[0] for d in entry["dependencies"]}
tomllib.loads((ROOT / "python/klbr-runtime/pyproject.toml").read_text())
return {"status": "passed", "meaning": "manifest/lock-reference consistency only; Cargo resolver not run"}
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--rust", action="store_true", help="run Cargo tests and lint checks")
parser.add_argument("--format", action="store_true", help="run rustfmt in write mode; requires --rust")
parser.add_argument("--portable-linker", action="store_true", help="override the existing Linux clang/wild config with cc")
parser.add_argument("--report", type=Path, help="write machine-readable evidence and separate step logs")
args = parser.parse_args()
if sys.version_info < (3, 11):
parser.error("Python >=3.11 is required")
if args.format and not args.rust:
parser.error("--format requires --rust")
if os.name != "posix":
parser.error("this first slice requires Unix-domain sockets (Linux/macOS)")
environment = os.environ.copy()
environment["PYTHONPATH"] = str(ROOT / "python/klbr-runtime/src")
environment["PYTHONDONTWRITEBYTECODE"] = "1"
environment["KLBR_PYTHON"] = sys.executable
if args.portable_linker:
# CARGO_ENCODED_RUSTFLAGS takes precedence over .cargo/config.toml.
# Empty intentionally clears --ld-path=wild, independently of Nushell.
environment["CARGO_ENCODED_RUSTFLAGS"] = ""
environment["CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER"] = "cc"
cargo_bin = Path.home() / ".cargo/bin"
if cargo_bin.exists() and str(cargo_bin) not in environment.get("PATH", ""):
environment["PATH"] = f"{cargo_bin}:{environment.get('PATH', '')}"
os.environ["PATH"] = environment["PATH"]
report = {
"created_at_utc": datetime.datetime.now(datetime.timezone.utc).isoformat(),
"python": sys.version,
"platform": platform.platform(),
"python_sqlite": sqlite3.sqlite_version,
"python_sqlite_scope": "serial in-memory migration tests only; not runtime WAL qualification",
"cargo_available": shutil.which("cargo") is not None,
"rustc_available": shutil.which("rustc") is not None,
"rust_checks_requested": args.rust,
"steps": [],
}
try:
report["manifests"] = static_contracts()
except (AssertionError, ValueError, StopIteration, KeyError) as error:
report["manifests"] = {"status": "failed", "error": str(error)}
def run(name: str, command: list[str]) -> None:
print(f"\n== {name} ==", flush=True)
started = time.monotonic()
try:
completed = subprocess.run(command, cwd=ROOT, env=environment,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
errors="replace", check=False)
code, output = completed.returncode, completed.stdout
except OSError as error:
code, output = 127, str(error)
print(output, end="" if output.endswith("\n") else "\n", flush=True)
step = {"name": name, "argv": command, "exit_code": code,
"elapsed_seconds": round(time.monotonic() - started, 3)}
if args.report:
args.report.parent.mkdir(parents=True, exist_ok=True)
log = args.report.with_name(f"{args.report.stem}-{name}.log")
log.write_text(output)
step["log"] = log.name
report["steps"].append(step)
run("python", [sys.executable, "-B", "-m", "unittest", "discover", "-s",
"python/klbr-runtime/tests", "-v"])
def run_wheel_smoke() -> None:
print("\n== wheel-packaging-smoke ==", flush=True)
started = time.monotonic()
with tempfile.TemporaryDirectory(prefix="klbr-wheel-smoke-") as tmp:
work = Path(tmp)
wheels_dir = work / "wheels"
wheels_dir.mkdir()
src = work / "source"
shutil.copytree(ROOT / "python/klbr-runtime", src,
ignore=shutil.ignore_patterns("__pycache__", "build", "*.egg-info"))
uv = shutil.which("uv")
pkg_venv_py = Path("/tmp/klbr-pkg-venv/bin/python")
if uv:
build_cmd = [uv, "build", "--wheel", str(src), "--out-dir", str(wheels_dir)]
elif pkg_venv_py.exists():
build_cmd = [str(pkg_venv_py), "-m", "pip", "wheel", "--no-deps",
"--no-build-isolation", "--no-index", str(src), "-w", str(wheels_dir)]
else:
build_cmd = [sys.executable, "-m", "pip", "wheel", "--no-deps",
"--no-build-isolation", "--no-index", str(src), "-w", str(wheels_dir)]
build_res = subprocess.run(build_cmd, cwd=work, capture_output=True, text=True, check=False)
if build_res.returncode != 0:
output = f"Wheel build failed:\n{build_res.stdout}\n{build_res.stderr}"
print(output, flush=True)
step = {"name": "wheel-packaging-smoke", "argv": build_cmd, "exit_code": build_res.returncode,
"elapsed_seconds": round(time.monotonic() - started, 3)}
report["steps"].append(step)
return
wheels = list(wheels_dir.glob("*.whl"))
if not wheels:
print("No wheel produced", flush=True)
step = {"name": "wheel-packaging-smoke", "argv": build_cmd, "exit_code": 1,
"elapsed_seconds": round(time.monotonic() - started, 3)}
report["steps"].append(step)
return
installed = work / "installed"
with zipfile.ZipFile(wheels[0]) as z:
z.extractall(installed)
smoke_env = dict(os.environ, PYTHONPATH=str(installed), PYTHONDONTWRITEBYTECODE="1")
import_cmd = [sys.executable, "-B", "-c",
"import klbr; tpls = klbr.templates.list_templates(); print(f'templates in wheel: {tpls}'); assert len(tpls) == 3"]
import_res = subprocess.run(import_cmd, cwd=work, env=smoke_env, capture_output=True, text=True, check=False)
output = import_res.stdout + import_res.stderr
print(output, end="" if output.endswith("\n") else "\n", flush=True)
step = {"name": "wheel-packaging-smoke", "argv": import_cmd, "exit_code": import_res.returncode,
"elapsed_seconds": round(time.monotonic() - started, 3)}
if args.report:
args.report.parent.mkdir(parents=True, exist_ok=True)
log = args.report.with_name(f"{args.report.stem}-wheel-smoke.log")
log.write_text(output)
step["log"] = log.name
report["steps"].append(step)
run_wheel_smoke()
if args.rust:
if not report["cargo_available"] or not report["rustc_available"]:
report["steps"].append({"name": "rust", "exit_code": 127,
"reason": "Cargo/rustc unavailable; no Rust tests or integration checks ran"})
else:
run("rust-version", ["rustc", "--version", "--verbose"])
run("rustfmt", ["cargo", "fmt", "-p", "klbr-runtime"] + ([] if args.format else ["--", "--check"]))
run("rust-tests", ["cargo", "test", "--locked", "-p", "klbr-runtime", "--all-targets"])
# Warnings are visible; denying all Clippy style lints before the
# first toolchain pass would hide more useful compilation evidence.
run("clippy", ["cargo", "clippy", "--locked", "-p", "klbr-runtime", "--all-targets"])
else:
report["rust_status"] = "not run; pass --rust on a machine with Cargo/rustc"
passed = report["manifests"]["status"] == "passed" and all(s["exit_code"] == 0 for s in report["steps"])
report["requested_checks_passed"] = passed
if args.report:
args.report.parent.mkdir(parents=True, exist_ok=True)
args.report.write_text(json.dumps(report, indent=2) + "\n")
print(f"\nEvidence: {args.report}")
return 0 if passed else 1
if __name__ == "__main__":
raise SystemExit(main())