forgexa-cli 1.84.3__tar.gz → 1.85.0__tar.gz

{forgexa_cli-1.84.3 → forgexa_cli-1.85.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.84.3
+Version: 1.85.0
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.84.3 → forgexa_cli-1.85.0}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.84.3"
+__version__ = "1.85.0"

{forgexa_cli-1.84.3 → forgexa_cli-1.85.0}/forgexa_cli/agent_core.py

@@ -85,19 +85,29 @@ def assess_approved_plan_conformance(baseline: dict, report: object) -> dict:
     ).encode()).hexdigest()
     if baseline.get("version") != 1 or result["baseline_fingerprint"] != fingerprint:
         result["reason"] = "approved_plan_baseline_invalid"
+        result["diagnostic_code"] = "approved_plan_baseline_invalid"
         return result
-    if not isinstance(report, dict) or (
-        report.get("baseline_fingerprint") != fingerprint
-        or report.get("task_id") != result["task_id"]
-        or report.get("status") not in ("conformant", "deviation", "unverified")
-    ):
+    if not isinstance(report, dict):
+        result["reason"] = "approved_plan_review_missing_or_mismatched"
+        result["diagnostic_code"] = "approved_plan_review_missing" if report is None else "approved_plan_review_invalid_payload"
+        return result
+    diagnostic = None
+    if report.get("baseline_fingerprint") != fingerprint:
+        diagnostic = "approved_plan_review_baseline_mismatch"
+    elif report.get("task_id") != result["task_id"]:
+        diagnostic = "approved_plan_review_task_mismatch"
+    elif report.get("status") not in ("conformant", "deviation", "unverified"):
+        diagnostic = "approved_plan_review_status_invalid"
+    if diagnostic is not None:
         result["reason"] = "approved_plan_review_missing_or_mismatched"
+        result["diagnostic_code"] = diagnostic
         return result
     evidence = report.get("evidence")
     if not isinstance(evidence, list) or not evidence or any(
         not isinstance(item, str) or not item.strip() for item in evidence
     ):
         result["reason"] = "approved_plan_review_evidence_missing"
+        result["diagnostic_code"] = "approved_plan_review_evidence_missing"
         return result
     result["status"] = report["status"]
     result["evidence_refs"] = [hashlib.sha256(item.encode()).hexdigest() for item in evidence]
@@ -295,20 +305,39 @@ def _assess_implementation_contributions(contract: dict, report: object) -> dict
             and len(criteria) == len(reserved_ids)
             and reserved_ids == [criterion.get("id") for criterion in criteria if isinstance(criterion, dict)]
         ):
+            index_map = deferred_contract.get("acceptance_criteria_indices")
+            expected_indices = {identifier: index for index, identifier in enumerate(reserved_ids, 1)}
+            valid_index_map = (
+                isinstance(index_map, dict) and set(index_map) == set(expected_indices)
+                and all(type(value) is int and value == expected_indices[identifier] for identifier, value in index_map.items())
+            )
             for criterion_id in reserved_ids:
                 match = re.fullmatch(r"AC-([0-9]+)", criterion_id)
-                if match is None or not 1 <= int(match.group(1)) <= len(contract.get("acceptance_criteria") or []):
+                index = index_map[criterion_id] if valid_index_map else int(match.group(1)) if index_map is None and match else 0
+                if not 1 <= index <= len(contract.get("acceptance_criteria") or []):
                     reserved_indexes.clear()
                     break
-                reserved_indexes.add(int(match.group(1)))
+                reserved_indexes.add(index)
             if len(reserved_indexes) != len(reserved_ids):
                 reserved_indexes.clear()
     acceptance_checks = []
     deferred_acceptance = []
+    subject = contract.get("subject_task_id")
+    prepared_verifier = (
+        not contract.get("final_verification") and task_types.get(subject) in ("testing", "verify")
+        and implementation_statuses.get(subject) == "covered"
+    )
     for row in report["acceptance_checks"]:
         if (
             row["index"] in reserved_indexes and row["status"] == "unverified" and row.get("plan_revision") is None
-            and all(implementation_statuses.get(task_id) == "covered" for task_id in row["task_ids"])
+            and (
+                all(implementation_statuses.get(task_id) == "covered" for task_id in row["task_ids"])
+                or prepared_verifier and subject in row["task_ids"] and all(
+                    implementation_statuses.get(task_id) == "covered"
+                    or task_id not in implementation_statuses and task_types.get(task_id) in ("coding", "fix")
+                    for task_id in row["task_ids"]
+                )
+            )
         ):
             deferred_acceptance.append(row["index"])
             continue
@@ -448,7 +477,16 @@ def assess_implementation_audit(contract: dict, report: object) -> dict:
                 description = row.get("description")
                 paths = row.get("files") or []
                 if not isinstance(description, str) or not description.strip() or not isinstance(paths, list):
-                    issues.append("Implementation gaps require an actionable description and file list")
+                    reference = f"task '{row['task_id']}'" if kind == "task" else f"acceptance index {row['index']}"
+                    invalid_fields = []
+                    if not isinstance(description, str) or not description.strip():
+                        invalid_fields.append("description must be non-empty text")
+                    if not isinstance(paths, list):
+                        invalid_fields.append("files must be a list; use files=[] when no source file is implicated")
+                    issues.append(
+                        "Implementation gaps require an actionable description and file list; "
+                        + reference + ": " + "; ".join(invalid_fields)
+                    )
                     continue
                 if any(
                     not isinstance(path, str) or not path.strip()

{forgexa_cli-1.84.3 → forgexa_cli-1.85.0}/forgexa_cli/daemon.py

@@ -1234,7 +1234,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.84.3"
+DAEMON_VERSION = "1.85.0"
 
 
 def _detect_client_type() -> str:
@@ -1668,7 +1668,8 @@ Review only the supplied task context, code diff and committed source snapshots.
 isolated review capsule, not the project workspace. Do not write or modify files,
 run mutating commands, create commits, or make network changes.
 
-Return exactly one JSON object with this schema:
+Return exactly one JSON object. This base schema must be extended with the task-bound
+plan_conformance field when a frozen approved baseline is supplied:
 {
   "verdict": "approve" | "request_changes" | "reject",
   "score": 0.0 to 1.0,
@@ -1741,9 +1742,19 @@ def _build_runtime_critic_prompt(
             "Implementation details may refine it but cannot silently replace its responsibilities, "
             "interfaces, required files or acceptance criteria. Report insufficient evidence honestly.",
             json.dumps(baseline, ensure_ascii=True, sort_keys=True),
-            'Also return "plan_conformance":{"baseline_fingerprint":"<frozen fingerprint>",'
-            '"task_id":"<frozen task id>","status":"conformant|deviation|unverified",'
-            '"evidence":["concrete supplied source/test reference"]}. '
+            "Bound review response example:\n" + json.dumps({
+                "verdict": "request_changes", "score": 0.5,
+                "summary": "<independent assessment of the supplied source and required checks>",
+                "dimension_scores": {}, "issues": [], "plan_conformance": {
+                    "baseline_fingerprint": baseline.get("fingerprint"),
+                    "task_id": (baseline.get("task") or {}).get("id"), "status": "unverified",
+                    "evidence": ["<concrete independently inspected source or check evidence>"],
+                },
+            }, ensure_ascii=True, separators=(",", ":")),
+            "The task-bound field is mandatory, including when issues is empty. Preserve its exact task_id "
+            "and baseline_fingerprint; do not substitute a requirement key, node UUID or your own digest. "
+            "Replace placeholder evidence with observed facts. Choose conformant, deviation or unverified "
+            "honestly; the example defaults to unverified and is not completion evidence. "
             "Assess every assigned obligation, including behavior omitted from the diff. "
             "Use deviation for an actual conflict or omission; use unverified when supplied evidence "
             "cannot establish conformance. A high quality score never replaces this conclusion. "
@@ -3189,6 +3200,10 @@ class _WorkspaceFileLock:
             handle.close()
 
 
+class _FreshAnalysisBranchError(RuntimeError):
+    code = "fresh_analysis_branch_reset_blocked"
+
+
 class WorkspaceManager:
     """Manages isolated workspaces per task using git worktrees."""
 
@@ -4818,6 +4833,83 @@ class WorkspaceManager:
             pass
         return False
 
+    async def _prepare_cloud_fresh_branch(
+        self, repository: Path, branch_name: str, default_branch: str, *, project_key: str,
+    ) -> None:
+        branch_ref = f"refs/heads/{branch_name}"
+        backup_ref = None
+        backup_ready = False
+        try:
+            if branch_name == default_branch:
+                raise RuntimeError("Fresh analysis cannot reset the project default branch")
+            await self._git("check-ref-format", branch_ref, cwd=repository)
+            await self._git(
+                "fetch", "origin", f"+{default_branch}:refs/remotes/origin/{default_branch}", cwd=repository,
+                timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+            )
+            tracking_ref = f"refs/remotes/origin/{branch_name}"
+            advertised = (await self._git(
+                "ls-remote", "--heads", "origin", branch_ref, cwd=repository,
+                timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+            )).strip()
+            if not advertised:
+                await self._git("update-ref", "-d", tracking_ref, cwd=repository)
+                logger.info("Fresh analysis branch %s is absent on origin; removed its stale tracking reference", branch_name)
+                return
+            remote_fields = advertised.split()
+            if len(remote_fields) != 2 or remote_fields[1] != branch_ref or not re.fullmatch(r"[0-9a-fA-F]{40}", remote_fields[0]):
+                raise RuntimeError("Fresh analysis requires an exact remote branch advertisement")
+            try:
+                await self._git(
+                    "fetch", "origin", f"+{branch_name}:{tracking_ref}", cwd=repository,
+                    timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+                )
+            except RuntimeError:
+                remaining = (await self._git(
+                    "ls-remote", "--heads", "origin", branch_ref, cwd=repository,
+                    timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+                )).strip()
+                if remaining:
+                    raise
+                await self._git("update-ref", "-d", tracking_ref, cwd=repository)
+                logger.info("Fresh analysis branch %s disappeared during fetch; removed its stale tracking reference", branch_name)
+                return
+            old_sha = (await self._git("rev-parse", "--verify", f"refs/remotes/origin/{branch_name}", cwd=repository)).strip()
+            default_sha = (await self._git("rev-parse", "--verify", f"refs/remotes/origin/{default_branch}", cwd=repository)).strip()
+            if not all(re.fullmatch(r"[0-9a-fA-F]{40}", value) for value in (old_sha, default_sha)):
+                raise RuntimeError("Fresh analysis requires verified remote branch commits")
+            if old_sha != remote_fields[0]:
+                raise RuntimeError("Remote requirement branch changed during fresh analysis preparation")
+            if old_sha == default_sha:
+                return
+            backup_ref = f"refs/tags/forgexa/fresh-analysis-backup/{branch_name}/{old_sha}"
+            await self._git("check-ref-format", backup_ref, cwd=repository)
+            existing = (await self._git(
+                "ls-remote", "--tags", "origin", backup_ref, cwd=repository,
+                timeout=settings.GIT_FETCH_TIMEOUT, project_key=project_key,
+            )).strip()
+            if existing:
+                if existing.split()[0] != old_sha:
+                    raise RuntimeError("Fresh analysis recovery reference has a different commit")
+            else:
+                await self._git(
+                    "push", "origin", f"{old_sha}:{backup_ref}", cwd=repository,
+                    timeout=settings.GIT_PUSH_TIMEOUT, project_key=project_key,
+                )
+            backup_ready = True
+            await self._git(
+                "push", f"--force-with-lease={branch_ref}:{old_sha}", "origin", f"{default_sha}:{branch_ref}",
+                cwd=repository, timeout=settings.GIT_PUSH_TIMEOUT, project_key=project_key,
+            )
+            await self._git("update-ref", f"refs/remotes/origin/{branch_name}", default_sha, cwd=repository)
+            logger.info("Prepared fresh analysis branch %s after preserving %s", branch_name, backup_ref)
+        except RuntimeError as error:
+            recovery = f" Recovery reference: {backup_ref}." if backup_ready else ""
+            raise _FreshAnalysisBranchError(
+                "Fresh analysis branch preparation failed; do not run the Agent or delete the remote branch."
+                + recovery + " " + self._git_push_diagnostic(error)
+            ) from error
+
     async def _branch_has_impl_commits(
         self, ws_path: Path, branch_name: str, default_branch: str,
     ) -> bool:
@@ -5239,19 +5331,8 @@ class WorkspaceManager:
                         fresh_start = False
 
                 if fresh_start:
-                    # Safety check: if the branch already has IMPLEMENTATION commits
-                    # beyond the default branch, do NOT reset to origin/default_branch
-                    # — that would destroy prior design/coding/testing work.
-                    #
-                    # Previous behaviour blocked the reset whenever *any* remote commit
-                    # existed, including analysis-only commits (PRD.md, cleanup wipes).
-                    # That was overly conservative: a branch whose only commits are
-                    # analysis documents is safe to reset for a fresh re-analysis
-                    # because no code has been written yet.
-                    #
-                    # The new check distinguishes:
-                    #   • analysis-only commits → safe to reset → allow fresh start
-                    #   • implementation commits (design/coding/testing) → block reset
+                    # Preserve existing implementation history before preparing a
+                    # confirmed fresh baseline; a failed preparation must stop here.
                     branch_has_impl = False
                     ahead_count = 0
                     try:
@@ -5270,55 +5351,9 @@ class WorkspaceManager:
                         )
 
                     if branch_has_impl:
-                        logger.warning(
-                            "Fresh start requested for %s: remote branch has implementation "
-                            "commit(s) ahead of %s — deleting remote branch to ensure "
-                            "a clean analysis environment (user explicitly chose fresh analysis)",
-                            branch_name, default_branch,
+                        await self._prepare_cloud_fresh_branch(
+                            ws_path, branch_name, default_branch, project_key=project_key,
                         )
-                        # When the user explicitly chooses "fresh analysis", they want a clean
-                        # slate.  Deleting the remote branch achieves this: the agent runs on
-                        # a new branch forked from default, completely free of prior
-                        # implementation commits that may have been wrong or irrelevant.
-                        # This is intentional and safe because:
-                        #   1. The user selected fresh analysis (not refine) — they accept
-                        #      that prior work on this branch will be discarded.
-                        #   2. Keeping the old implementation commits would contaminate the
-                        #      fresh analysis with incorrect context (the original bug report).
-                        #   3. "Refine" mode preserves the branch — fresh mode does not.
-                        try:
-                            await self._git(
-                                "push", "origin", "--delete", branch_name,
-                                cwd=ws_path,
-                                timeout=settings.GIT_PUSH_TIMEOUT,
-                                project_key=project_key,
-                            )
-                            logger.info(
-                                "Deleted remote branch %s for fresh analysis restart",
-                                branch_name,
-                            )
-                            # Also remove local branch reference so checkout -B below starts clean
-                            try:
-                                await self._git("branch", "-D", branch_name, cwd=ws_path)
-                            except RuntimeError:
-                                pass  # Local branch may not exist; not an error
-                            # Remove the remote-tracking ref so git doesn't think the
-                            # branch still exists on the remote
-                            try:
-                                await self._git(
-                                    "update-ref", "-d", f"refs/remotes/origin/{branch_name}",
-                                    cwd=ws_path,
-                                )
-                            except RuntimeError:
-                                pass
-                        except RuntimeError as _del_err:
-                            logger.warning(
-                                "Failed to delete remote branch %s: %s — "
-                                "proceeding with reset to origin/%s instead",
-                                branch_name, _del_err, default_branch,
-                            )
-                        # fresh_start remains True: checkout -B below will recreate
-                        # the branch from origin/default_branch
                     elif ahead_count > 0:
                         # Branch has commits but they are all analysis-only (safe to reset).
                         logger.info(
@@ -5698,11 +5733,8 @@ class WorkspaceManager:
                 except RuntimeError as exc:
                     last_branch_fetch_error = self._summarize_git_error(exc)
 
-        # Fresh analysis with an existing remote branch that has implementation commits:
-        # delete the remote branch so the agent starts from a clean slate.
-        # We must do this check here (new worktree path) as well as in the existing
-        # worktree path above, because the daemon that runs a fresh re-analysis may
-        # never have processed this requirement before (no ws_path yet).
+        # Prepare the same recoverable fresh baseline on runtimes without a
+        # previous worktree for this requirement.
         if fresh_start and branch_exists_remote:
             # Check for implementation commits — same logic as in the existing worktree path.
             _new_branch_has_impl = False
@@ -5722,44 +5754,9 @@ class WorkspaceManager:
                 )
 
             if _new_branch_has_impl:
-                logger.warning(
-                    "Fresh analysis (new worktree) for %s: remote branch has implementation "
-                    "commit(s) — deleting remote branch for a clean analysis environment",
-                    branch_name,
+                await self._prepare_cloud_fresh_branch(
+                    main_repo, branch_name, default_branch, project_key=project_key,
                 )
-                try:
-                    await self._git(
-                        "push", "origin", "--delete", branch_name,
-                        cwd=main_repo,
-                        timeout=settings.GIT_PUSH_TIMEOUT,
-                        project_key=project_key,
-                    )
-                    logger.info(
-                        "Deleted remote branch %s for fresh analysis restart (new worktree path)",
-                        branch_name,
-                    )
-                    # Remove local branch ref and remote-tracking ref
-                    try:
-                        await self._git("branch", "-D", branch_name, cwd=main_repo)
-                    except RuntimeError:
-                        pass
-                    try:
-                        await self._git(
-                            "update-ref", "-d", f"refs/remotes/origin/{branch_name}",
-                            cwd=main_repo,
-                        )
-                    except RuntimeError:
-                        pass
-                    # Branch no longer exists on remote
-                    branch_exists_remote = False
-                except RuntimeError as _del_err2:
-                    logger.warning(
-                        "Failed to delete remote branch %s (new worktree path): %s — "
-                        "proceeding with worktree add from default branch",
-                        branch_name, _del_err2,
-                    )
-                    # Treat as if branch doesn't exist to force fresh worktree
-                    branch_exists_remote = False
 
         if expect_branch and not fresh_start and not branch_exists_remote:
             self._safe_rmtree(ws_path)
@@ -14019,6 +14016,7 @@ class RuntimeDaemon:
             paths = agent_core.missing_planned_task_files({
                 "files": planned.get("files") or [], "items": planned.get("items") or [],
             }, [])
+            assigned_paths = list(paths)
             primary_paths = list(paths)
             if planned.get("type") in ("testing", "review") and getattr(task, "requirement_key", ""):
                 output_dir = str((task.input_data or {}).get("output_dir") or "").replace("\\", "/").rstrip("/")
@@ -14106,8 +14104,7 @@ class RuntimeDaemon:
                     paths = [*primary_paths, *confirmed, *paths]
                 except Exception:
                     coverage["reference_inventory_unavailable"] = True
-            paths.extend(changed_files)
-            paths = list(dict.fromkeys(paths))
+            paths = list(dict.fromkeys([*assigned_paths, *changed_files, *paths]))
             coverage["candidate_files"] = len(paths)
             remaining = _RUNTIME_CRITIC_DIFF_MAX_CHARS - len(diff or "")
             source_context = []
@@ -14252,8 +14249,23 @@ class RuntimeDaemon:
                     "agent_attempts": [attempt],
                     **metadata,
                 }
-            if not task.local_evidence_upload and isinstance(baseline, dict):
-                conformance = agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"))
+            conformance = (
+                agent_core.assess_approved_plan_conformance(baseline, structured_result.get("plan_conformance"))
+                if isinstance(baseline, dict) else None
+            )
+            if conformance is not None and conformance["status"] != "conformant":
+                diagnostic_lines = [f"[daemon] Local independent review: {conformance['status']}."]
+                if conformance.get("reason"):
+                    diagnostic_lines.append(
+                        "[daemon] Review contract diagnostic: " + conformance.get("diagnostic_code", conformance["reason"])
+                    )
+                else:
+                    diagnostic_lines.extend(
+                        "[daemon] Review evidence: " + re.sub(r"https?://\S+", "[redacted-url]", item.replace("\x00", ""))[:600]
+                        for item in structured_result["plan_conformance"]["evidence"][:10]
+                    )
+                _append_local_bind_output_log(task.task_id, diagnostic_lines)
+            if not task.local_evidence_upload and conformance is not None:
                 score = structured_result.get("score")
                 verdict = structured_result.get("verdict")
                 structured_result = {
@@ -14414,6 +14426,7 @@ class RuntimeDaemon:
 
         audit_contract = input_data.get("implementation_audit_contract")
         result.metrics.pop("implementation_audit_node_complete", None)
+        result.metrics.pop("implementation_audit_subject_blocked", None)
         if isinstance(audit_contract, dict):
             agent_id = str(result.metrics.get("actual_agent") or getattr(task, "agent_type", "") or "")
             audit_report = agent_core.extract_implementation_audit(_daemon_extract_agent_output(agent_id, result.stdout))
@@ -14427,6 +14440,11 @@ class RuntimeDaemon:
             result.metrics["implementation_audit_node_complete"] = bool(
                 audit_result["report_valid"] and audit_result["node_complete"]
             )
+            result.metrics["implementation_audit_subject_blocked"] = bool(
+                audit_result["report_valid"] and not audit_result["node_complete"]
+                and any(finding.get("task_id") == audit_contract.get("subject_task_id") and finding.get("status") == "blocked"
+                        for finding in audit_result.get("findings") or [])
+            )
             if audit_result["report_valid"] and audit_result["status"] == "plan_revision_required":
                 result.status = "failed"
                 result.failure_code = "implementation_plan_revision_required"
@@ -16450,6 +16468,21 @@ class RuntimeDaemon:
                     *[f"[daemon] {issue}" for issue in issues],
                 ])
 
+            if (
+                agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
+                and result.metrics.get("implementation_audit_subject_blocked") is True
+            ):
+                result.status = "failed"
+                result.failure_code = "implementation_audit_incomplete"
+                result.error = (
+                    str(next((issue for issue in issues if issue.code == "implementation_audit_incomplete"), issues[0]))
+                    + ". Resolve the reported verification prerequisites before retrying; "
+                    "rewriting artifacts does not execute blocked acceptance checks."
+                )
+                _record_output_validation_issues(result, issues)
+                self._record_testing_telemetry(workspace_path, task, result, retries_used=attempt)
+                return result
+
             if (
                 agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
                 and all(
@@ -16638,6 +16671,11 @@ class RuntimeDaemon:
                 elif audit_incomplete:
                     result.failure_code = "implementation_audit_incomplete"
                     result.error = "; ".join(remaining[:3])
+                    if (
+                        agent_core.is_implementation_testing_task(task.node_type, task.input_data or {})
+                        and result.metrics.get("implementation_audit_subject_blocked") is True
+                    ):
+                        result.error += ". Resolve the reported verification prerequisites before retrying."
                 else:
                     result.failure_code = "validation_retry_exhausted"
                     result.error = (

{forgexa_cli-1.84.3 → forgexa_cli-1.85.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.84.3
+Version: 1.85.0
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.84.3 → forgexa_cli-1.85.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.84.3"
+version = "1.85.0"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = "MIT"