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

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

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

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

{forgexa_cli-1.47.2 → 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.2"
+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},
                 },

{forgexa_cli-1.47.2 → 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.2 → forgexa_cli-1.47.3}/forgexa_cli/runtime_evidence.py

@@ -14,7 +14,6 @@ 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"
@@ -25,6 +24,7 @@ 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")
@@ -53,6 +53,13 @@ _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*$"
@@ -711,7 +718,7 @@ def parse_acceptance_criteria_coverage_artifacts(
         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_LINT_ISSUES]:
+    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")
@@ -725,24 +732,28 @@ def parse_acceptance_criteria_coverage_artifacts(
         ):
             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_LINT_ISSUES:
+    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_LINT_ISSUES]:
+    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"))
-        status = raw_criterion.get("status")
-        covered_by = raw_criterion.get("covered_by")
+        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(status, str)
-            or status.strip().lower() != "covered"
             or not isinstance(covered_by, list)
-            or not covered_by
+            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] = []
@@ -760,8 +771,9 @@ def parse_acceptance_criteria_coverage_artifacts(
             "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_LINT_ISSUES:
+    if len(coverage_matrix_document["acceptance_criteria"]) > _MAX_ACCEPTANCE_CRITERIA_COVERAGE_ITEMS:
         return _acceptance_criteria_coverage_failure("coverage_matrix_limit_exceeded")
     return {
         "status": "completed",
@@ -1449,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.2 → 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.2
+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.2 → forgexa_cli-1.47.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.47.2"
+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.2 → 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))