feat(cta): emit short GitHub-style webview PR links

webview_url now builds /owner/repo/pull/<pr>?run=<run_id> instead of the
long ?repo=&ref=&compare=&pr=&run_id=&artifact=&artifact_url= query. The
webview re-derives the head SHA, base SHA, and artifact name from the run's
uploaded artifact + its metadata.json, so the comment link carries only the
PR number and run id. Trim the CTA plumbing in action.yml accordingly
(ARTIFACT_NAME stays the readiness gate; only --run-id is passed through).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Svilen-Stefanov

action.yml

@@ -1368,15 +1368,14 @@ runs:
         # committed to the PR branch.
         cta() {
           local extra=()
+          # ARTIFACT_NAME presence is the readiness gate (an analysis artifact was
+          # uploaded for this run). The short webview link itself needs only the run id
+          # — the webview re-derives head/base/artifact from the run + its metadata.
           if [ -n "$WEBVIEW_BASE" ] && [ -n "$ARTIFACT_NAME" ]; then
             extra+=(
               --webview-ready
               --webview-base "$WEBVIEW_BASE"
-              --head-sha "$HEAD_SHA"
-              --base-sha "$BASE_SHA"
               --run-id "$RUN_ID"
-              --artifact-name "$ARTIFACT_NAME"
-              --artifact-url "$ARTIFACT_URL"
             )
           fi
           python3 "$ACTION_PATH/scripts/build_cta.py" \

scripts/build_cta.py

@@ -3,8 +3,9 @@
 The body is a single line — "Explore this PR's architecture in your browser or
 VS Code" — that merges the hosted-webview link with the editor link(s), preceded by
 a warning banner when real health findings exist. The "browser" link (a no-install
-hosted webview) is included only when ``webview_ready`` and points at the uploaded
-GitHub Actions artifact for this PR analysis. With a click proxy (``cta_base``) the
+hosted webview) is included only when ``webview_ready``; it's a short GitHub-style
+link (``/owner/repo/pull/<pr>?run=<run_id>``) that the webview resolves to this PR's
+uploaded analysis artifact for the run. With a click proxy (``cta_base``) the
 editor link routes through it (owner/repo/pr tracked) and deep-links into the editor
 (the proxy redirects to a ``vscode:``/``cursor:`` URL), and a separate "install the
 extension" link is appended. Without a proxy GitHub's comment sanitizer strips custom
@@ -63,35 +64,21 @@ def webview_url(
     webview_base: str,
     owner: str,
     repo: str,
-    head_sha: str,
-    base_sha: str,
     *,
     pr: str = "",
     run_id: str = "",
-    artifact_name: str = "",
-    artifact_url: str = "",
 ) -> str | None:
-    """Return the hosted-webview deep-link URL for this PR's head-vs-comparison-branch diff, or None.
+    """Return the hosted-webview PR deep-link, or None.
 
-    Deep-links straight to the diff. The base/head SHAs pin the code comparison;
-    the optional run/artifact fields let the webview load PR-specific analysis
-    data from the workflow artifact instead of from the PR branch.
+    A GitHub-style short link: ``{base}/{owner}/{repo}/pull/{pr}?run={run_id}``. The
+    webview re-derives the head SHA, base SHA, and artifact name from the workflow
+    run's uploaded artifact (+ its metadata.json), so the link carries only the PR
+    number and the run id — short, and stable across re-runs.
     """
-    if not (webview_base and owner and repo and head_sha):
+    if not (webview_base and owner and repo and pr and run_id):
         return None
     base = webview_base.rstrip("/")
-    params = {"repo": f"{owner}/{repo}", "ref": head_sha}
-    if base_sha:
-        params["compare"] = base_sha
-    if pr:
-        params["pr"] = pr
-    if run_id:
-        params["run_id"] = run_id
-    if artifact_name:
-        params["artifact"] = artifact_name
-    if artifact_url:
-        params["artifact_url"] = artifact_url
-    return f"{base}/?{urlencode(params)}"
+    return f"{base}/{owner}/{repo}/pull/{pr}?{urlencode({'run': run_id})}"
 
 
 def _join_or(items: list[str]) -> str:
@@ -112,12 +99,8 @@ def build_cta(
     issues: int = 0,
     *,
     webview_base: str = "",
-    head_sha: str = "",
-    base_sha: str = "",
     webview_ready: bool = False,
     run_id: str = "",
-    artifact_name: str = "",
-    artifact_url: str = "",
 ) -> str:
     """Return the markdown CTA footer: a health-warning banner plus an editor link.
 
@@ -127,8 +110,9 @@ def build_cta(
     ``vscode:``/``cursor:`` schemes), and the redundant install link is dropped.
     The ⚠️ banner shows whenever ``issues > 0``.
 
-    When ``webview_ready`` a "explore in browser" line deep-links the hosted
-    webview to this PR's artifact-backed head-vs-comparison-branch diff.
+    When ``webview_ready`` an "explore in browser" line deep-links the hosted webview
+    to this PR's diff (``/owner/repo/pull/<pr>?run=<run_id>``); the webview re-derives
+    the head/base/artifact from the run, so only the PR number and run id are needed.
     """
     parts: list[str] = []
     if issues > 0:
@@ -154,17 +138,7 @@ def link(path: str, **extra: str) -> str:
     # "in your browser or VS Code" / "in VS Code".
     targets: list[str] = []
     if webview_ready:
-        wv = webview_url(
-            webview_base,
-            owner,
-            repo,
-            head_sha,
-            base_sha,
-            pr=pr,
-            run_id=run_id,
-            artifact_name=artifact_name,
-            artifact_url=artifact_url,
-        )
+        wv = webview_url(webview_base, owner, repo, pr=pr, run_id=run_id)
         if wv:
             targets.append(f"your [**browser**]({wv})")
     targets += [f"[**{_EDITOR_LABEL[e]}**]({editor_href[e]})" for e in editors]
@@ -187,11 +161,7 @@ def main() -> int:
     p.add_argument("--repo-path", required=True, type=Path, help="Path to the analyzed repo checkout")
     p.add_argument("--issues", default="0", help="Real architecture-issue count (0 -> no warning banner)")
     p.add_argument("--webview-base", default="", help="Hosted webview base URL (e.g. https://app.codeboarding.org)")
-    p.add_argument("--head-sha", default="", help="PR head SHA the webview link pins to")
-    p.add_argument("--base-sha", default="", help="Comparison-branch SHA the webview link compares against")
     p.add_argument("--run-id", default="", help="GitHub Actions run id containing the PR analysis artifact")
-    p.add_argument("--artifact-name", default="", help="GitHub Actions artifact name containing PR analysis data")
-    p.add_argument("--artifact-url", default="", help="GitHub Actions artifact URL containing PR analysis data")
     p.add_argument(
         "--webview-ready",
         action="store_true",
@@ -212,12 +182,8 @@ def main() -> int:
             args.repo_path,
             issues,
             webview_base=args.webview_base,
-            head_sha=args.head_sha,
-            base_sha=args.base_sha,
             webview_ready=args.webview_ready,
             run_id=args.run_id,
-            artifact_name=args.artifact_name,
-            artifact_url=args.artifact_url,
         )
     )
     return 0

tests/test_build_cta.py

@@ -79,39 +79,31 @@ def test_trailing_slash_in_base_is_normalized(self):
 class TestWebviewUrl(unittest.TestCase):
     WV = "https://app.codeboarding.org"
 
-    def test_url_built_with_head_ref_and_compare_base(self):
-        url = bc.webview_url(self.WV, "Org", "Repo", "headsha", "basesha")
-        self.assertIn("https://app.codeboarding.org/?", url)
-        self.assertIn("repo=Org%2FRepo", url)
-        self.assertIn("ref=headsha", url)
-        self.assertIn("compare=basesha", url)
-        self.assertFalse(url.startswith("🌐"))  # a bare URL now, not a markdown line
-
-    def test_url_omits_compare_when_no_base(self):
-        url = bc.webview_url(self.WV, "o", "r", "headsha", "")
-        self.assertIn("ref=headsha", url)
+    def test_url_is_github_style_pr_path(self):
+        url = bc.webview_url(self.WV, "Org", "Repo", pr="9", run_id="123")
+        self.assertEqual(url, "https://app.codeboarding.org/Org/Repo/pull/9?run=123")
+
+    def test_url_carries_only_pr_path_and_run(self):
+        # Head/base SHAs and the artifact name/url are re-derived by the webview, so
+        # none of them appear in the short link.
+        url = bc.webview_url(self.WV, "o", "r", pr="9", run_id="123")
+        self.assertIn("/o/r/pull/9", url)
+        self.assertIn("run=123", url)
+        self.assertNotIn("ref=", url)
         self.assertNotIn("compare=", url)
+        self.assertNotIn("artifact", url)
+        self.assertNotIn("repo=o%2Fr", url)  # not the old query-style link
 
-    def test_url_includes_artifact_lookup_params(self):
-        url = bc.webview_url(
-            self.WV,
-            "o",
-            "r",
-            "headsha",
-            "basesha",
-            pr="9",
-            run_id="123",
-            artifact_name="codeboarding-pr-9-headsha",
-            artifact_url="https://github.com/o/r/actions/runs/123/artifacts/456",
-        )
-        self.assertIn("pr=9", url)
-        self.assertIn("run_id=123", url)
-        self.assertIn("artifact=codeboarding-pr-9-headsha", url)
-        self.assertIn("artifact_url=https%3A%2F%2Fgithub.com%2Fo%2Fr%2Factions%2Fruns%2F123%2Fartifacts%2F456", url)
+    def test_url_none_without_pr_or_run(self):
+        self.assertIsNone(bc.webview_url(self.WV, "o", "r", pr="9"))  # no run
+        self.assertIsNone(bc.webview_url(self.WV, "o", "r", run_id="123"))  # no pr
+        self.assertIsNone(bc.webview_url("", "o", "r", pr="9", run_id="123"))  # no base
 
-    def test_url_none_without_head_sha_or_base(self):
-        self.assertIsNone(bc.webview_url(self.WV, "o", "r", "", "basesha"))
-        self.assertIsNone(bc.webview_url("", "o", "r", "headsha", "basesha"))
+    def test_trailing_slash_in_webview_base_is_normalized(self):
+        a = bc.webview_url("https://app.codeboarding.org/", "o", "r", pr="9", run_id="1")
+        b = bc.webview_url("https://app.codeboarding.org", "o", "r", pr="9", run_id="1")
+        self.assertEqual(a, b)
+        self.assertNotIn(".org//", a)
 
     def test_cta_includes_browser_link_when_ready(self):
         out = bc.build_cta(
@@ -122,14 +114,12 @@ def test_cta_includes_browser_link_when_ready(self):
             repo_with(),
             issues=0,
             webview_base=self.WV,
-            head_sha="headsha",
-            base_sha="basesha",
             webview_ready=True,
+            run_id="123",
         )
         self.assertIn("Explore this PR", out)
         self.assertIn("your [**browser**](", out)
-        self.assertIn("ref=headsha", out)
-        self.assertIn("compare=basesha", out)
+        self.assertIn("/Org/Repo/pull/9?run=123", out)
         self.assertIn("VS Code", out)  # editor merged into the same line
 
     def test_cta_omits_browser_link_when_not_ready(self):
@@ -142,11 +132,10 @@ def test_cta_omits_browser_link_when_not_ready(self):
             repo_with(),
             issues=0,
             webview_base=self.WV,
-            head_sha="headsha",
-            base_sha="basesha",
             webview_ready=False,
+            run_id="123",
         )
-        self.assertNotIn("ref=headsha", out)  # no browser link
+        self.assertNotIn("/pull/", out)  # no browser link
         self.assertNotIn("[**browser**]", out)
         self.assertIn("Explore this PR", out)  # the line is still there, editor-only
         self.assertIn("VS Code", out)
@@ -160,12 +149,11 @@ def test_cta_omits_browser_link_when_ready_but_no_base_url(self):
             repo_with(),
             issues=0,
             webview_base="",
-            head_sha="headsha",
-            base_sha="basesha",
             webview_ready=True,
+            run_id="123",
         )
         self.assertNotIn("[**browser**]", out)
-        self.assertNotIn("ref=headsha", out)
+        self.assertNotIn("/pull/", out)
 
 
 class TestJoinOr(unittest.TestCase):
@@ -179,9 +167,7 @@ class TestMergedExploreLine(unittest.TestCase):
     WV = "https://app.codeboarding.org"
 
     def _ready(self, repo, cta=""):
-        return bc.build_cta(
-            cta, "o", "r", "1", repo, webview_base=self.WV, head_sha="h", base_sha="b", webview_ready=True
-        )
+        return bc.build_cta(cta, "o", "r", "1", repo, webview_base=self.WV, webview_ready=True, run_id="123")
 
     def test_browser_and_single_editor_joined_with_or(self):
         out = self._ready(repo_with())  # default VS Code