| """AgentArk task catalog compatibility and selection (standard library only). |
| |
| A task's labeled env_version is its minimum supported environment version. |
| All later environment versions are supported by project policy. This is not |
| a statement that every task has been executed on every later environment. |
| """ |
|
|
| import argparse |
| import json |
| import re |
| from pathlib import Path |
|
|
|
|
| COMPATIBILITY_POLICY = { |
| "id": "minimum-env-version-v1", |
| "rule": "environment_version >= min_env_version", |
| "minimum_field": "min_env_version", |
| "legacy_minimum_field": "env_version", |
| "specifier_field": "env_version_spec", |
| "forward_compatible": True, |
| "version_comparison": "numeric dotted components; missing components are zero", |
| "compatible_env_versions_semantics": "known published compatible versions; not exhaustive and not a test matrix", |
| "validation_semantics": "existing validation fields and evidence describe actual tests only", |
| "requirements_semantics": "platform and separately declared wrapper/capability requirements still apply", |
| } |
|
|
|
|
| def version_key(value: str) -> tuple[int, ...]: |
| """Compare 1.0.10 numerically; regard 1.0 and 1.0.0 as equal.""" |
| if not isinstance(value, str) or not re.fullmatch(r"\d+(?:\.\d+)*", value): |
| raise ValueError(f"Expected a numeric dotted environment version, got {value!r}") |
| parts = [int(part) for part in value.split(".")] |
| while len(parts) > 1 and parts[-1] == 0: |
| parts.pop() |
| return tuple(parts) |
|
|
|
|
| def minimum_env_version(row: dict) -> str: |
| labeled = row["env_version"] |
| minimum = row.get("min_env_version", labeled) |
| if version_key(minimum) != version_key(labeled): |
| raise ValueError(f"Minimum contradicts labeled env_version for {row.get('path', row.get('task_id'))}") |
| return minimum |
|
|
|
|
| def supports_environment(row: dict, env_version: str) -> bool: |
| return version_key(env_version) >= version_key(minimum_env_version(row)) |
|
|
|
|
| def normalize_task(row: dict, published_env_versions) -> dict: |
| """Add range metadata without altering artifact identity or test evidence.""" |
| minimum = minimum_env_version(row) |
| known = set(published_env_versions) | set(row.get("compatible_env_versions", [])) | {minimum} |
| for version in known: |
| version_key(version) |
| compatible = sorted((v for v in known if supports_environment(row, v)), key=lambda v: (version_key(v), v)) |
| return { |
| **row, |
| "min_env_version": minimum, |
| "env_version_spec": f">={minimum}", |
| "env_compatibility_policy": COMPATIBILITY_POLICY["id"], |
| "compatible_env_versions": compatible, |
| } |
|
|
|
|
| def select_tasks(rows: list[dict], env_version: str, platform: str | None = None, |
| task_ids: set[int] | None = None) -> list[dict]: |
| """Latest compatible task version per task/platform; no downloads or install. |
| |
| An unsupported new task version must not hide an older compatible version. |
| Separately declared requirements are returned intact for the caller to honor. |
| """ |
| version_key(env_version) |
| selected = {} |
| def rank(row): |
| task_version = row["task_version"] |
| if task_version.startswith("v"): |
| task_version = task_version[1:] |
| return version_key(task_version), version_key(minimum_env_version(row)), row["path"] |
| for row in rows: |
| if platform is not None and row["platform"] != platform: |
| continue |
| if task_ids is not None and int(row["task_id"]) not in task_ids: |
| continue |
| if not supports_environment(row, env_version): |
| continue |
| key = (int(row["task_id"]), row["platform"]) |
| if key not in selected or rank(row) > rank(selected[key]): |
| selected[key] = row |
| return [selected[key] for key in sorted(selected)] |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--registry", type=Path, required=True, help="Downloaded registry/tasks.jsonl") |
| parser.add_argument("--env-version", required=True) |
| parser.add_argument("--platform", choices=("windows", "linux")) |
| parser.add_argument("--task-id", type=int, action="append", help="Repeat to select multiple task IDs") |
| args = parser.parse_args() |
| rows = [json.loads(line) for line in args.registry.read_text(encoding="utf-8-sig").splitlines() if line.strip()] |
| try: |
| selected = select_tasks(rows, args.env_version, args.platform, set(args.task_id) if args.task_id else None) |
| if args.task_id and {int(r["task_id"]) for r in selected} != set(args.task_id): |
| parser.error("At least one requested task has no compatible artifact for this environment/platform") |
| except (ValueError, KeyError) as exc: |
| parser.error(str(exc)) |
| for row in selected: |
| print(json.dumps(row, ensure_ascii=False, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
