forgexa-cli 1.47.1__tar.gz → 1.47.3__tar.gz

{forgexa_cli-1.47.1 → forgexa_cli-1.47.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.1
+Version: 1.47.3
 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.47.1 → forgexa_cli-1.47.3}/forgexa_cli/__init__.py

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

{forgexa_cli-1.47.1 → forgexa_cli-1.47.3}/forgexa_cli/daemon.py

@@ -1075,7 +1075,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.47.1"
+DAEMON_VERSION = "1.47.3"
 
 
 def _detect_client_type() -> str:
@@ -7908,7 +7908,7 @@ class ServerConnection:
             "capabilities": {
                 "platform": platform.platform(),
                 "python_version": platform.python_version(),
-                "local_workspace_bindings": {"protocol_version": 2},
+                "local_workspace_bindings": {"protocol_version": 3},
             },
             "server_url": self.server_url,
             "expires_in_days": 90,
@@ -8306,7 +8306,7 @@ class ServerConnection:
                 "capabilities": {
                     "platform": platform.platform(),
                     "python_version": platform.python_version(),
-                    "local_workspace_bindings": {"protocol_version": 2},
+                    "local_workspace_bindings": {"protocol_version": 3},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                     "local_evidence": {"protocol_version": 1, "structured_summary": True},
                 },
@@ -10463,6 +10463,12 @@ class RuntimeDaemon:
                         result,
                         before_sha=node_before_sha,
                     )
+                    await self._collect_runtime_acceptance_criteria_coverage_evidence(
+                        workspace_path,
+                        task,
+                        result,
+                        before_sha=node_before_sha,
+                    )
 
             # 6. Report completion (include actual agent used if different from requested)
             result.metrics["actual_agent"] = agent.agent_id
@@ -13292,11 +13298,15 @@ class RuntimeDaemon:
                 "summary": "The committed source revision is unavailable for evidence collection.",
             }
         else:
+            evidence_check = {
+                **check,
+                "output_dir": self._resolve_task_output_dir(task),
+            }
             run = await self._run_runtime_evidence_in_worktree(
                 workspace_path,
                 task,
                 after_sha,
-                check,
+                evidence_check,
                 runtime_evidence.run_test_coverage_evidence,
             )
 
@@ -13344,7 +13354,10 @@ class RuntimeDaemon:
             "artifact_refs": [artifact_ref],
             "runtime_evidence": evidence_identity,
         }
-        for key in ("test_pass_rate", "passed", "failed", "skipped", "errors", "total", "failed_tests"):
+        for key in (
+            "test_pass_rate", "passed", "failed", "skipped", "errors", "total",
+            "failed_tests", "test_case_results", "exit_code",
+        ):
             if key in run:
                 test_observation[key] = run[key]
         if run.get("failure_reason"):
@@ -13723,6 +13736,83 @@ class RuntimeDaemon:
             observation["collection_failure_reason"] = run["failure_reason"]
         result.observations.append(observation)
 
+    async def _collect_runtime_acceptance_criteria_coverage_evidence(
+        self,
+        workspace_path: Path,
+        task: TaskInfo,
+        result: TaskResult,
+        *,
+        before_sha: str,
+    ) -> None:
+        """Bind generated testing artifacts to the committed testing attempt."""
+        if task.workspace_resolution != "cloud_worktree" or task.node_type != "testing":
+            return
+
+        after_sha = str((result.git or {}).get("commit_sha") or "").strip()
+        check = {"output_dir": self._resolve_task_output_dir(task)}
+        if re.fullmatch(r"[0-9a-fA-F]{40}", after_sha) is None:
+            run = {
+                "status": "source_commit_unavailable",
+                "collection_status": "unavailable",
+                "failure_reason": "source_commit_unavailable",
+                "coverage_links": [],
+                "source_artifacts": [],
+                "summary": "The committed source revision is unavailable for acceptance-criteria evidence.",
+            }
+        else:
+            run = await self._run_runtime_evidence_in_worktree(
+                workspace_path,
+                task,
+                after_sha,
+                check,
+                runtime_evidence.run_acceptance_criteria_coverage_evidence,
+            )
+        run.setdefault("coverage_links", [])
+        run.setdefault("source_artifacts", [])
+
+        source_commit_range = {"after_sha": after_sha} if after_sha else {}
+        if re.fullmatch(r"[0-9a-fA-F]{40}", before_sha or ""):
+            source_commit_range["before_sha"] = before_sha
+        report = {
+            "version": runtime_evidence.RUNTIME_EVIDENCE_PLAN_VERSION,
+            "execution_attempt_id": task.execution_attempt_id,
+            "check_kind": runtime_evidence.ACCEPTANCE_CRITERIA_COVERAGE_CHECK_KIND,
+            "source_commit_range": source_commit_range,
+            "result": run,
+        }
+        report_content = json.dumps(report, sort_keys=True, separators=(",", ":"))
+        report_checksum = hashlib.sha256(report_content.encode("utf-8")).hexdigest()
+        artifact_path = (
+            f".forgexa/evidence/{task.task_id}/{after_sha[:12] or 'unavailable'}/"
+            "acceptance-criteria.json"
+        )
+        artifact_ref = {"path": artifact_path, "checksum": report_checksum}
+        result.artifacts.append({
+            "path": artifact_path,
+            "content": report_content,
+            "content_hash": report_checksum,
+            "type": "application/vnd.forgexa.gate-evidence+json",
+            "system_generated": True,
+            "artifact_role": "gate_evidence_report",
+        })
+        observation = {
+            "type": runtime_evidence.ACCEPTANCE_CRITERIA_COVERAGE_CHECK_KIND,
+            "collection_status": run.get("collection_status"),
+            "summary": run.get("summary"),
+            "artifact_refs": [artifact_ref],
+            "runtime_evidence": {
+                "version": runtime_evidence.RUNTIME_EVIDENCE_PLAN_VERSION,
+                "check_kind": runtime_evidence.ACCEPTANCE_CRITERIA_COVERAGE_CHECK_KIND,
+                "execution_attempt_id": task.execution_attempt_id,
+                "source_commit_range": source_commit_range,
+            },
+            "coverage_links": run.get("coverage_links", []),
+            "source_artifacts": run.get("source_artifacts", []),
+        }
+        if run.get("failure_reason"):
+            observation["collection_failure_reason"] = run["failure_reason"]
+        result.observations.append(observation)
+
     async def _collect_staged_diff_stats(self, cwd: Path) -> dict:
         """Collect staged diff stats for building a rich commit message."""
         status_map: dict[str, str] = {}

{forgexa_cli-1.47.1 → forgexa_cli-1.47.3}/forgexa_cli/main.py

@@ -1017,16 +1017,29 @@ def _version_is_newer(candidate: str, reference: str) -> bool:
         return False
 
 
-def _run_update_check() -> None:
-    """Fetch the latest published CLI version and refresh the local cache."""
+def _latest_published_cli_version() -> str:
+    """Return the current forgexa-cli version from the official PyPI API."""
     try:
         import httpx
 
         with httpx.Client(timeout=5) as client:
-            resp = client.get("https://pypi.org/pypi/forgexa-cli/json")
-            resp.raise_for_status()
-            latest = str(resp.json()["info"]["version"])
-        _write_update_cache(latest)
+            response = client.get("https://pypi.org/pypi/forgexa-cli/json")
+            response.raise_for_status()
+            version = _normalize_target_version(str(response.json()["info"]["version"]))
+    except Exception as exc:
+        raise RuntimeError(
+            "Could not determine the latest forgexa-cli release from PyPI. "
+            "Check access to pypi.org or specify --target-version."
+        ) from exc
+    if version is None:
+        raise RuntimeError("PyPI did not return a forgexa-cli version.")
+    return version
+
+
+def _run_update_check() -> None:
+    """Fetch the latest published CLI version and refresh the local cache."""
+    try:
+        _write_update_cache(_latest_published_cli_version())
     except Exception:
         pass  # Network errors are silently ignored
 
@@ -1581,13 +1594,15 @@ def _run_windows_upgrade_worker(payload: str) -> None:
         parent_pid = int(data["parent_pid"])
         launcher_paths = data.get("launcher_paths", [])
         daemon_stopped = bool(data.get("daemon_stopped"))
-        target_version = str(data.get("target_version") or "latest")
+        target_version = str(data.get("target_version") or "").strip()
     except (KeyError, TypeError, ValueError, json.JSONDecodeError):
         return
     if not isinstance(command, list) or not all(isinstance(part, str) for part in command):
         return
     if not isinstance(launcher_paths, list) or not all(isinstance(path, str) for path in launcher_paths):
         return
+    if not target_version:
+        return
 
     try:
         log_path = _upgrade_log_path()
@@ -1608,6 +1623,13 @@ def _run_windows_upgrade_worker(payload: str) -> None:
             if result.returncode != 0:
                 log_file.write(f"Upgrade failed (returncode={result.returncode}).\n")
                 return
+            installed_version = _installed_cli_version()
+            if installed_version != target_version:
+                log_file.write(
+                    f"Upgrade failed: expected {target_version}, "
+                    f"installed {installed_version or 'unknown'}.\n"
+                )
+                return
             log_file.write("Upgrade complete.\n")
             if daemon_stopped:
                 restarted, server_url = _start_daemon_after_upgrade()
@@ -3446,12 +3468,14 @@ def cmd_version(args: argparse.Namespace) -> None:
 def cmd_upgrade(args: argparse.Namespace) -> None:
     try:
         target_version = _normalize_target_version(getattr(args, "target_version", None))
+        if target_version is None:
+            target_version = _latest_published_cli_version()
         plan = _build_upgrade_plan(target_version)
     except (RuntimeError, ValueError) as exc:
         print(str(exc), file=sys.stderr)
         sys.exit(1)
 
-    if target_version and target_version == plan.current_version:
+    if target_version == plan.current_version:
         print(f"forgexa-cli {plan.current_version} is already installed.")
         return
 
@@ -3470,7 +3494,7 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         print(f"Stopped local daemon (PID {daemon_pid}) before upgrade.")
 
     print(f"Current version : {plan.current_version}")
-    print(f"Target version  : {target_version or 'latest'}")
+    print(f"Target version  : {target_version}")
     print(f"Upgrade mode    : {plan.installer}")
     print(f"Running         : {shlex.join(plan.command)}")
 
@@ -3494,6 +3518,20 @@ def cmd_upgrade(args: argparse.Namespace) -> None:
         sys.exit(result.returncode or 1)
 
     installed_version = _installed_cli_version() or "unknown"
+    if installed_version != target_version:
+        print(
+            f"Upgrade did not install the requested version {target_version}; "
+            f"installed version is {installed_version}. "
+            "The configured package index, proxy, or constraint may be stale.",
+            file=sys.stderr,
+        )
+        if daemon_stopped:
+            print(
+                "The local daemon was stopped before the upgrade attempt. "
+                "Restart it manually after resolving the package source issue.",
+                file=sys.stderr,
+            )
+        sys.exit(1)
     print(f"Upgrade complete. Installed version: {installed_version}")
     if daemon_stopped:
         restarted, server_url = _start_daemon_after_upgrade()

{forgexa_cli-1.47.1 → forgexa_cli-1.47.3}/forgexa_cli/runtime_evidence.py

@@ -1,26 +1,32 @@
 """Portable planning and parsing for controlled runtime evidence checks."""
 from __future__ import annotations
 
+import ast
 import asyncio
 import hashlib
 import json
+import os
 import re
 import shlex
+import tempfile
 import time
+import xml.etree.ElementTree as ElementTree
 from pathlib import Path
 from typing import Any
 
-
 RUNTIME_EVIDENCE_PLAN_VERSION = 1
 TEST_COVERAGE_CHECK_KIND = "test_coverage"
 STATIC_CHECK_KIND = "static_check"
 TYPE_CHECK_KIND = "type_check"
 SECURITY_CHECK_KIND = "security_check"
+ACCEPTANCE_CRITERIA_COVERAGE_CHECK_KIND = "acceptance_criteria_coverage"
 LOCAL_EVIDENCE_SUMMARY_VERSION = 1
 _DEFAULT_TIMEOUT_SECONDS = 600
 _MAX_FAILED_TESTS = 20
 _MAX_LINT_ISSUES = 50
+_MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS = 200
 _MAX_OUTPUT_CHARS = 100_000
+_MAX_TEST_CASE_RESULTS = 200
 _SHELL_METACHARACTERS = (";", "`", "$", ">", "<", "&", "|", "\n", "\r", "\x00")
 _SENSITIVE_ARGUMENT = re.compile(
     r"^-{1,2}(?:api[-_]?key|authorization|password|secret|token)(?:=|$)",
@@ -41,6 +47,19 @@ _BANDIT_SECURITY_CHECK_ARGV = (
 _SAFE_LOCAL_TEST_NAME = re.compile(r"^[A-Za-z0-9_./:-]+$")
 _SAFE_LOCAL_RUFF_RULE = re.compile(r"^[A-Za-z][A-Za-z0-9_-]{0,199}$")
 _SAFE_SECURITY_RULE = re.compile(r"^[A-Za-z][A-Za-z0-9_.-]{0,199}$")
+_SAFE_TEST_CASE_ID = re.compile(r"^[A-Za-z][A-Za-z0-9_.:-]{0,99}$")
+_SAFE_TEST_INTENT_ID = re.compile(r"^[A-Za-z][A-Za-z0-9_.:-]{0,99}$")
+_SAFE_ACCEPTANCE_REFERENCE = re.compile(r"^AC-(\d+)$", re.IGNORECASE)
+_CANONICAL_TEST_CASE_ID = re.compile(r"^TC-(?:00[1-9]|0[1-9]\d|[1-9]\d{2})$", re.IGNORECASE)
+_TEST_CASE_MARKER = re.compile(r"(?<![A-Za-z0-9_-])TC-(\d+)(?![A-Za-z0-9_-])", re.IGNORECASE)
+_SAFE_PYTHON_IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_COVERAGE_DECLARED_OUTCOMES = frozenset({
+    "covered",
+    "partial",
+    "uncovered",
+    "unverifiable",
+    "not_applicable",
+})
 _MYPY_DIAGNOSTIC = re.compile(
     r"^(?P<file>[^:\n]+):(?P<line>[1-9]\d*)(?::(?P<column>[1-9]\d*))?: "
     r"error: (?P<message>.+?)(?:\s+\[(?P<code>[A-Za-z0-9_-]+)\])?\s*$"
@@ -676,6 +695,348 @@ def parse_bandit_json_output(output: object, exit_code: int) -> dict[str, Any]:
     return result
 
 
+def parse_acceptance_criteria_coverage_artifacts(
+    test_cases_output: object,
+    coverage_matrix_output: object,
+) -> dict[str, Any]:
+    """Project bounded AC-to-test-case links without retaining raw artifacts."""
+    test_cases_text = _bounded_evidence_text(test_cases_output)
+    coverage_matrix_text = _bounded_evidence_text(coverage_matrix_output)
+    if test_cases_text is None or coverage_matrix_text is None:
+        return _acceptance_criteria_coverage_failure("acceptance_criteria_artifact_too_large")
+    try:
+        test_cases_document = json.loads(test_cases_text)
+        coverage_matrix_document = json.loads(coverage_matrix_text)
+    except json.JSONDecodeError:
+        return _acceptance_criteria_coverage_failure("acceptance_criteria_json_unparseable")
+    if (
+        not isinstance(test_cases_document, dict)
+        or not isinstance(test_cases_document.get("test_cases"), list)
+        or not isinstance(coverage_matrix_document, dict)
+        or not isinstance(coverage_matrix_document.get("acceptance_criteria"), list)
+    ):
+        return _acceptance_criteria_coverage_failure("acceptance_criteria_json_invalid_shape")
+
+    test_case_intents: dict[str, str] = {}
+    for raw_test_case in test_cases_document["test_cases"][:_MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS]:
+        if not isinstance(raw_test_case, dict):
+            return _acceptance_criteria_coverage_failure("test_case_invalid")
+        test_case_id = raw_test_case.get("id")
+        intent_id = raw_test_case.get("intent_id") or raw_test_case.get("test_intent_id")
+        if (
+            not isinstance(test_case_id, str)
+            or _SAFE_TEST_CASE_ID.fullmatch(test_case_id.strip()) is None
+            or not isinstance(intent_id, str)
+            or _SAFE_TEST_INTENT_ID.fullmatch(intent_id.strip()) is None
+            or test_case_id.strip() in test_case_intents
+        ):
+            return _acceptance_criteria_coverage_failure("test_case_invalid")
+        test_case_intents[test_case_id.strip()] = intent_id.strip()
+    if len(test_cases_document["test_cases"]) > _MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS:
+        return _acceptance_criteria_coverage_failure("test_case_limit_exceeded")
+
+    coverage_links: list[dict[str, Any]] = []
+    seen_acceptance_ids: set[str] = set()
+    for raw_criterion in coverage_matrix_document["acceptance_criteria"][:_MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS]:
+        if not isinstance(raw_criterion, dict):
+            return _acceptance_criteria_coverage_failure("coverage_matrix_invalid")
+        acceptance_id = _canonical_acceptance_criteria_reference(raw_criterion.get("id"))
+        raw_status = raw_criterion.get("status")
+        declared_outcome = raw_status.strip().lower() if isinstance(raw_status, str) else ""
+        covered_by = raw_criterion.get("covered_by", [])
+        if (
+            acceptance_id is None
+            or acceptance_id in seen_acceptance_ids
+            or not isinstance(covered_by, list)
+            or declared_outcome not in _COVERAGE_DECLARED_OUTCOMES
+            or (declared_outcome == "covered" and not covered_by)
+            or (
+                declared_outcome in {"uncovered", "unverifiable", "not_applicable"}
+                and covered_by
+            )
+        ):
+            return _acceptance_criteria_coverage_failure("coverage_matrix_invalid")
+        test_case_ids: list[str] = []
+        for raw_test_case_id in covered_by:
+            if (
+                not isinstance(raw_test_case_id, str)
+                or raw_test_case_id.strip() not in test_case_intents
+            ):
+                return _acceptance_criteria_coverage_failure("coverage_matrix_test_case_unknown")
+            test_case_id = raw_test_case_id.strip()
+            if test_case_id not in test_case_ids:
+                test_case_ids.append(test_case_id)
+        seen_acceptance_ids.add(acceptance_id)
+        coverage_links.append({
+            "acceptance_criteria_ref": acceptance_id,
+            "test_case_ids": test_case_ids,
+            "test_intent_ids": [test_case_intents[test_case_id] for test_case_id in test_case_ids],
+            "declared_outcome": declared_outcome,
+        })
+    if len(coverage_matrix_document["acceptance_criteria"]) > _MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS:
+        return _acceptance_criteria_coverage_failure("coverage_matrix_limit_exceeded")
+    return {
+        "status": "completed",
+        "collection_status": "completed",
+        "coverage_links": coverage_links,
+        "summary": f"Validated {len(coverage_links)} acceptance-criteria coverage link(s).",
+    }
+
+
+async def run_acceptance_criteria_coverage_evidence(
+    workspace_path: str | Path,
+    check: object,
+) -> dict[str, Any]:
+    """Read bounded testing artifacts from a committed detached worktree."""
+    output_dir = check.get("output_dir") if isinstance(check, dict) else None
+    paths = acceptance_criteria_coverage_artifact_paths(output_dir)
+    if paths is None:
+        return _acceptance_criteria_coverage_unavailable(
+            "testing_artifact_path_unavailable",
+        )
+    test_cases_path, coverage_matrix_path = paths
+    test_cases_content, test_cases_reason = _read_bounded_workspace_file(
+        workspace_path,
+        test_cases_path,
+    )
+    coverage_matrix_content, coverage_matrix_reason = _read_bounded_workspace_file(
+        workspace_path,
+        coverage_matrix_path,
+    )
+    if test_cases_content is None or coverage_matrix_content is None:
+        reason = (
+            "testing_artifact_too_large"
+            if "too_large" in {test_cases_reason, coverage_matrix_reason}
+            else "testing_artifact_unavailable"
+        )
+        return _acceptance_criteria_coverage_unavailable(reason)
+
+    report = parse_acceptance_criteria_coverage_artifacts(
+        test_cases_content,
+        coverage_matrix_content,
+    )
+    report["source_artifacts"] = [
+        {
+            "path": test_cases_path,
+            "sha256": hashlib.sha256(test_cases_content.encode("utf-8")).hexdigest(),
+        },
+        {
+            "path": coverage_matrix_path,
+            "sha256": hashlib.sha256(coverage_matrix_content.encode("utf-8")).hexdigest(),
+        },
+    ]
+    return report
+
+
+def _temporary_junit_report_path() -> Path | None:
+    try:
+        descriptor, raw_path = tempfile.mkstemp(
+            prefix="forgexa-pytest-evidence-",
+            suffix=".xml",
+        )
+    except OSError:
+        return None
+    try:
+        os.close(descriptor)
+    except OSError:
+        try:
+            Path(raw_path).unlink(missing_ok=True)
+        except OSError:
+            pass
+        return None
+    return Path(raw_path)
+
+
+def _test_case_results_from_junit(
+    workspace_path: str | Path,
+    output_dir: object,
+    junit_path: Path,
+) -> list[dict[str, str]]:
+    paths = acceptance_criteria_coverage_artifact_paths(output_dir)
+    if paths is None:
+        return []
+    test_cases_content, _ = _read_bounded_workspace_file(workspace_path, paths[0])
+    if test_cases_content is None:
+        return []
+    try:
+        test_cases_document = json.loads(test_cases_content)
+    except json.JSONDecodeError:
+        return []
+    declared_ids = _declared_test_case_ids(test_cases_document)
+    if not declared_ids:
+        return []
+    junit_content = _read_bounded_file_bytes(junit_path)
+    if junit_content is None:
+        return []
+    try:
+        junit_document = ElementTree.fromstring(junit_content)
+    except ElementTree.ParseError:
+        return []
+
+    workspace_root = Path(workspace_path).resolve()
+    outcomes: dict[str, str] = {}
+    marker_cache: dict[tuple[str, tuple[str, ...], str], set[str]] = {}
+    for testcase in junit_document.iter():
+        if _xml_tag_name(testcase.tag) != "testcase":
+            continue
+        classname = testcase.get("classname")
+        test_name = testcase.get("name")
+        source = _pytest_junit_source_file(workspace_root, classname)
+        function_name = _pytest_junit_function_name(test_name)
+        if source is None or function_name is None:
+            continue
+        source_path, class_path = source
+        cache_key = (str(source_path), class_path, function_name)
+        case_ids = marker_cache.get(cache_key)
+        if case_ids is None:
+            case_ids = _test_case_ids_in_python_test(
+                source_path,
+                class_path,
+                function_name,
+                set(declared_ids),
+            )
+            marker_cache[cache_key] = case_ids
+        outcome = _pytest_junit_outcome(testcase)
+        for case_id in case_ids:
+            outcomes[case_id] = _more_conservative_test_outcome(
+                outcomes.get(case_id),
+                outcome,
+            )
+    return [
+        {"id": case_id, "outcome": outcomes[case_id]}
+        for case_id in declared_ids
+        if case_id in outcomes
+    ]
+
+
+def _declared_test_case_ids(document: object) -> list[str]:
+    if not isinstance(document, dict) or not isinstance(document.get("test_cases"), list):
+        return []
+    test_cases = document["test_cases"]
+    if len(test_cases) > _MAX_TEST_CASE_RESULTS:
+        return []
+    identifiers: list[str] = []
+    for test_case in test_cases:
+        identifier = test_case.get("id") if isinstance(test_case, dict) else None
+        if not isinstance(identifier, str) or _CANONICAL_TEST_CASE_ID.fullmatch(identifier) is None:
+            return []
+        identifier = identifier.upper()
+        if identifier in identifiers:
+            return []
+        identifiers.append(identifier)
+    return identifiers
+
+
+def _pytest_junit_source_file(
+    workspace_root: Path,
+    classname: object,
+) -> tuple[Path, tuple[str, ...]] | None:
+    if not isinstance(classname, str) or not classname:
+        return None
+    components = classname.split(".")
+    if not all(_SAFE_PYTHON_IDENTIFIER.fullmatch(component) for component in components):
+        return None
+    for source_end in range(len(components), 0, -1):
+        relative_path = "/".join(components[:source_end]) + ".py"
+        if not _safe_workspace_path(relative_path):
+            return None
+        try:
+            source_path = (workspace_root / relative_path).resolve(strict=True)
+            source_path.relative_to(workspace_root)
+        except (OSError, ValueError):
+            continue
+        if source_path.is_file():
+            return source_path, tuple(components[source_end:])
+    return None
+
+
+def _pytest_junit_function_name(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    name = value.split("[", 1)[0]
+    return name if _SAFE_PYTHON_IDENTIFIER.fullmatch(name) else None
+
+
+def _test_case_ids_in_python_test(
+    source_path: Path,
+    class_path: tuple[str, ...],
+    function_name: str,
+    declared_ids: set[str],
+) -> set[str]:
+    source_content = _read_bounded_file_bytes(source_path)
+    if source_content is None:
+        return set()
+    try:
+        source_text = source_content.decode("utf-8")
+    except UnicodeDecodeError:
+        return set()
+    try:
+        document = ast.parse(source_text)
+    except SyntaxError:
+        return set()
+    lines = source_text.splitlines()
+    matched_ids: set[str] = set()
+
+    def visit(nodes: list[ast.stmt], parent_classes: tuple[str, ...]) -> None:
+        for child in nodes:
+            if isinstance(child, ast.ClassDef):
+                visit(child.body, (*parent_classes, child.name))
+            elif (
+                isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef))
+                and child.name == function_name
+                and parent_classes == class_path
+            ):
+                start_line = min(
+                    [child.lineno, *(decorator.lineno for decorator in child.decorator_list)],
+                )
+                while start_line > 1 and lines[start_line - 2].lstrip().startswith("#"):
+                    start_line -= 1
+                end_line = child.end_lineno or child.lineno
+                matched_ids.update(
+                    _test_case_ids_from_marker_text(
+                        "\n".join(lines[start_line - 1:end_line]),
+                        declared_ids,
+                    )
+                )
+
+    visit(document.body, ())
+    return matched_ids
+
+
+def _test_case_ids_from_marker_text(value: str, declared_ids: set[str]) -> set[str]:
+    return {
+        f"TC-{int(match.group(1)):03d}"
+        for match in _TEST_CASE_MARKER.finditer(value)
+        if 1 <= int(match.group(1)) <= 999
+        and f"TC-{int(match.group(1)):03d}" in declared_ids
+    }
+
+
+def _pytest_junit_outcome(testcase: ElementTree.Element) -> str:
+    child_tags = {_xml_tag_name(child.tag) for child in testcase}
+    if child_tags & {"failure", "error"}:
+        return "failed"
+    return "skipped" if "skipped" in child_tags else "passed"
+
+
+def _more_conservative_test_outcome(current: str | None, incoming: str) -> str:
+    severity = {"skipped": 0, "passed": 1, "failed": 2}
+    return incoming if current is None or severity[incoming] > severity[current] else current
+
+
+def _xml_tag_name(value: object) -> str:
+    return value.rsplit("}", 1)[-1] if isinstance(value, str) else ""
+
+
+def _read_bounded_file_bytes(file_path: Path) -> bytes | None:
+    try:
+        with file_path.open("rb") as handle:
+            content = handle.read(_MAX_OUTPUT_CHARS + 1)
+    except OSError:
+        return None
+    return content if len(content) <= _MAX_OUTPUT_CHARS else None
+
+
 async def run_test_coverage_evidence(
     workspace_path: str | Path,
     check: object,
@@ -694,50 +1055,70 @@ async def run_test_coverage_evidence(
     timeout_seconds = (
         timeout if isinstance(timeout, int) and 1 <= timeout <= 3600 else _DEFAULT_TIMEOUT_SECONDS
     )
+    junit_path = _temporary_junit_report_path()
+    execution_argv = [
+        *argv,
+        f"--junitxml={junit_path}",
+    ] if junit_path is not None else argv
     started_at = time.monotonic()
     try:
-        process = await asyncio.create_subprocess_exec(
-            *argv,
-            cwd=str(Path(workspace_path)),
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-    except FileNotFoundError:
-        return {
-            "status": "tool_unavailable",
-            "collection_status": "unavailable",
-            "failure_reason": "python_unavailable",
-            "summary": "Python is unavailable on this runtime.",
-            "duration_ms": int((time.monotonic() - started_at) * 1000),
-        }
-    except OSError:
-        return {
-            "status": "tool_unavailable",
-            "collection_status": "unavailable",
-            "failure_reason": "pytest_start_failed",
-            "summary": "pytest could not be started on this runtime.",
-            "duration_ms": int((time.monotonic() - started_at) * 1000),
-        }
-
-    try:
-        stdout, stderr = await asyncio.wait_for(process.communicate(), timeout_seconds)
-    except asyncio.TimeoutError:
-        process.kill()
-        await process.communicate()
-        return {
-            "status": "timed_out",
-            "collection_status": "unavailable",
-            "failure_reason": "timeout",
-            "summary": f"pytest evidence collection timed out after {timeout_seconds}s.",
-            "duration_ms": int((time.monotonic() - started_at) * 1000),
-        }
-
-    output = (stdout + b"\n" + stderr).decode("utf-8", errors="replace")
-    report = parse_pytest_coverage_output(output, process.returncode or 0)
-    report["duration_ms"] = int((time.monotonic() - started_at) * 1000)
-    report["tool"] = "pytest"
-    report["command"] = command
-    return report
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *execution_argv,
+                cwd=str(Path(workspace_path)),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+        except FileNotFoundError:
+            return {
+                "status": "tool_unavailable",
+                "collection_status": "unavailable",
+                "failure_reason": "python_unavailable",
+                "summary": "Python is unavailable on this runtime.",
+                "duration_ms": int((time.monotonic() - started_at) * 1000),
+            }
+        except OSError:
+            return {
+                "status": "tool_unavailable",
+                "collection_status": "unavailable",
+                "failure_reason": "pytest_start_failed",
+                "summary": "pytest could not be started on this runtime.",
+                "duration_ms": int((time.monotonic() - started_at) * 1000),
+            }
+
+        try:
+            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout_seconds)
+        except asyncio.TimeoutError:
+            process.kill()
+            await process.communicate()
+            return {
+                "status": "timed_out",
+                "collection_status": "unavailable",
+                "failure_reason": "timeout",
+                "summary": f"pytest evidence collection timed out after {timeout_seconds}s.",
+                "duration_ms": int((time.monotonic() - started_at) * 1000),
+            }
+
+        output = (stdout + b"\n" + stderr).decode("utf-8", errors="replace")
+        report = parse_pytest_coverage_output(output, process.returncode or 0)
+        if junit_path is not None and report.get("collection_status") == "completed":
+            test_case_results = _test_case_results_from_junit(
+                workspace_path,
+                check.get("output_dir") if isinstance(check, dict) else None,
+                junit_path,
+            )
+            if test_case_results:
+                report["test_case_results"] = test_case_results
+        report["duration_ms"] = int((time.monotonic() - started_at) * 1000)
+        report["tool"] = "pytest"
+        report["command"] = command
+        return report
+    finally:
+        if junit_path is not None:
+            try:
+                junit_path.unlink(missing_ok=True)
+            except OSError:
+                pass
 
 
 async def run_static_check_evidence(
@@ -997,6 +1378,78 @@ def _safe_evidence_message(value: object) -> str:
     return text[:1000]
 
 
+def _bounded_evidence_text(value: object) -> str | None:
+    return value if isinstance(value, str) and len(value) <= _MAX_OUTPUT_CHARS else None
+
+
+def acceptance_criteria_coverage_artifact_paths(
+    output_dir: object,
+) -> tuple[str, str] | None:
+    """Return the sole pair of testing-artifact paths allowed for P3 evidence."""
+    if not isinstance(output_dir, str):
+        return None
+    normalized = output_dir.strip().replace("\\", "/")
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    if not _safe_workspace_path(normalized):
+        return None
+    return (
+        f"{normalized}/test-cases.json",
+        f"{normalized}/coverage-matrix.json",
+    )
+
+
+def _read_bounded_workspace_file(
+    workspace_path: str | Path,
+    relative_path: str,
+) -> tuple[str | None, str]:
+    """Read one UTF-8 repository file without following a path outside root."""
+    root = Path(workspace_path).resolve()
+    try:
+        file_path = (root / relative_path).resolve(strict=True)
+        file_path.relative_to(root)
+        if not file_path.is_file():
+            return None, "unavailable"
+        with file_path.open("rb") as handle:
+            content = handle.read(_MAX_OUTPUT_CHARS + 1)
+    except (OSError, ValueError):
+        return None, "unavailable"
+    if len(content) > _MAX_OUTPUT_CHARS:
+        return None, "too_large"
+    try:
+        return content.decode("utf-8"), "completed"
+    except UnicodeDecodeError:
+        return None, "unavailable"
+
+
+def _canonical_acceptance_criteria_reference(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    match = _SAFE_ACCEPTANCE_REFERENCE.fullmatch(value.strip())
+    return f"AC-{int(match.group(1)):03d}" if match is not None else None
+
+
+def _acceptance_criteria_coverage_failure(reason: str) -> dict[str, Any]:
+    return {
+        "status": "parse_failed",
+        "collection_status": "incomplete",
+        "failure_reason": reason,
+        "coverage_links": [],
+        "summary": "Testing artifacts did not provide a usable acceptance-criteria coverage map.",
+    }
+
+
+def _acceptance_criteria_coverage_unavailable(reason: str) -> dict[str, Any]:
+    return {
+        "status": "artifact_unavailable",
+        "collection_status": "unavailable",
+        "failure_reason": reason,
+        "coverage_links": [],
+        "source_artifacts": [],
+        "summary": "Testing artifacts are unavailable for acceptance-criteria evidence.",
+    }
+
+
 def _security_score(high: int, medium: int, low: int) -> float:
     if high > 0:
         return 0.0
@@ -1008,4 +1461,4 @@ def _security_score(high: int, medium: int, low: int) -> float:
         return 0.8
     if low > 0:
         return max(0.85, 1.0 - low * 0.03)
-    return 1.0
+    return 1.0

{forgexa_cli-1.47.1 → forgexa_cli-1.47.3}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.1
+Version: 1.47.3
 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.47.1 → forgexa_cli-1.47.3}/pyproject.toml

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

{forgexa_cli-1.47.1 → forgexa_cli-1.47.3}/tests/test_auth_and_runtime_commands.py

@@ -730,6 +730,66 @@ def test_cmd_upgrade_runs_planned_command(monkeypatch: pytest.MonkeyPatch) -> No
     assert "Upgrade complete. Installed version: 1.12.3" in output
 
 
+def test_cmd_upgrade_resolves_latest_to_an_explicit_pypi_version(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    plan = main.UpgradePlan(
+        installer="pipx",
+        command=["pipx", "install", "--force", "forgexa-cli==1.12.3"],
+        current_version="1.12.2",
+        target_version="1.12.3",
+    )
+    calls: list[list[str]] = []
+
+    def build_upgrade_plan(target_version: str | None) -> main.UpgradePlan:
+        assert target_version == "1.12.3"
+        return plan
+
+    monkeypatch.setattr(main, "_latest_published_cli_version", lambda: "1.12.3")
+    monkeypatch.setattr(main, "_build_upgrade_plan", build_upgrade_plan)
+    monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (False, None))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.3")
+    monkeypatch.setattr(main, "_start_daemon_after_upgrade", lambda: (False, None))
+    monkeypatch.setattr(
+        main.subprocess,
+        "run",
+        lambda command: calls.append(command) or SimpleNamespace(returncode=0),
+    )
+
+    buffer = io.StringIO()
+    with contextlib.redirect_stdout(buffer):
+        main.cmd_upgrade(SimpleNamespace(target_version=None))
+
+    assert calls == [["pipx", "install", "--force", "forgexa-cli==1.12.3"]]
+    assert "Target version  : 1.12.3" in buffer.getvalue()
+
+
+def test_cmd_upgrade_rejects_success_when_target_version_is_not_installed(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    plan = main.UpgradePlan(
+        installer="pipx",
+        command=["pipx", "install", "--force", "forgexa-cli==1.12.3"],
+        current_version="1.12.2",
+        target_version="1.12.3",
+    )
+    restart_calls: list[bool] = []
+
+    monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: plan)
+    monkeypatch.setattr(main, "_normalize_target_version", lambda value: value)
+    monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (True, 4242))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.2")
+    monkeypatch.setattr(main, "_start_daemon_after_upgrade", lambda: restart_calls.append(True))
+    monkeypatch.setattr(main.subprocess, "run", lambda command: SimpleNamespace(returncode=0))
+
+    with pytest.raises(SystemExit, match="1"):
+        main.cmd_upgrade(SimpleNamespace(target_version="1.12.3"))
+
+    assert restart_calls == []
+    assert "did not install the requested version 1.12.3" in capsys.readouterr().err
+
+
 def test_cmd_upgrade_defers_windows_install_until_cli_exits(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -812,6 +872,7 @@ def test_windows_upgrade_worker_waits_before_running_pip(
         "run",
         lambda command, **kwargs: events.append("run") or SimpleNamespace(returncode=0),
     )
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.3")
 
     main._run_windows_upgrade_worker(
         json.dumps(
@@ -838,6 +899,7 @@ def test_windows_upgrade_worker_restarts_stopped_daemon_after_success(
     monkeypatch.setattr(main, "_upgrade_log_path", lambda: log_path)
     monkeypatch.setattr(main, "_wait_for_windows_upgrade_release", lambda *args: True)
     monkeypatch.setattr(main.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.3")
     monkeypatch.setattr(
         main,
         "_start_daemon_after_upgrade",
@@ -860,6 +922,38 @@ def test_windows_upgrade_worker_restarts_stopped_daemon_after_success(
     assert "Daemon restarted in background (server=https://api.example.com)." in log_path.read_text()
 
 
+def test_windows_upgrade_worker_does_not_restart_when_version_is_not_installed(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    log_path = tmp_path / "upgrade.log"
+    restart_calls: list[bool] = []
+    monkeypatch.setattr(main, "_upgrade_log_path", lambda: log_path)
+    monkeypatch.setattr(main, "_wait_for_windows_upgrade_release", lambda *args: True)
+    monkeypatch.setattr(main.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+    monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.12.2")
+    monkeypatch.setattr(
+        main,
+        "_start_daemon_after_upgrade",
+        lambda: restart_calls.append(True) or (True, "https://api.example.com"),
+    )
+
+    main._run_windows_upgrade_worker(
+        json.dumps(
+            {
+                "command": ["python", "-m", "pip", "install", "--upgrade", "forgexa-cli"],
+                "parent_pid": 4242,
+                "launcher_paths": [],
+                "daemon_stopped": True,
+                "target_version": "1.12.3",
+            }
+        )
+    )
+
+    assert restart_calls == []
+    assert "Upgrade failed: expected 1.12.3, installed 1.12.2." in log_path.read_text()
+
+
 def test_cmd_upgrade_restarts_background_daemon_after_success(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -873,6 +967,7 @@ def test_cmd_upgrade_restarts_background_daemon_after_success(
 
     monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: plan)
     monkeypatch.setattr(main, "_normalize_target_version", lambda value: value)
+    monkeypatch.setattr(main, "_latest_published_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (True, 4242))
     monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main.subprocess, "run", lambda cmd: SimpleNamespace(returncode=0))
@@ -905,6 +1000,7 @@ def test_cmd_upgrade_keeps_manual_restart_hint_when_auto_restart_skips(
 
     monkeypatch.setattr(main, "_build_upgrade_plan", lambda target: plan)
     monkeypatch.setattr(main, "_normalize_target_version", lambda value: value)
+    monkeypatch.setattr(main, "_latest_published_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main, "_stop_daemon_if_running", lambda: (True, 4242))
     monkeypatch.setattr(main, "_installed_cli_version", lambda: "1.16.4")
     monkeypatch.setattr(main.subprocess, "run", lambda cmd: SimpleNamespace(returncode=0))