end

  end

  @doc "The unified diff between two commits, byte-capped with a truncation flag."

  def diff_range(repo, base, head) do

    with :ok <- check(repo, head),

         {:ok, base_full} <- resolve_commit(repo, base),

         {:ok, head_full} <- resolve_commit_from_cache(repo, head) do

      case git(repo, ["diff", "-M", "--no-color", "--end-of-options", base_full, head_full]) do

        {output, 0} -> {:ok, truncate(output, @diff_cap), byte_size(output) > @diff_cap}

        _ -> {:error, :not_found}

      end

    end

  end

  @doc "Directory listing at `ref`/`path` as `[%{name, kind, size}]`, bounded."

  def tree(repo, ref, path \\ "") do

    with :ok <- check(repo, ref),

  alias OpenAgents.Accounts.User

  alias OpenAgents.Forge.Browse

  alias OpenAgents.Forge.GitPlane

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

    end

  end

  @doc """

  The review ranges for a stacked pull request.

  The layer diff runs from the entry's stored boundary OID to its observed

  head OID, so it holds only this layer's commits. The cumulative preview

  runs from the current trunk tip to the head and answers what the

  repository looks like once everything through this position lands. The

  boundary is `:stale` when the parent branch was rewritten so the stored

  boundary is no longer reachable from the parent's current tip; a stale

  layer diff would silently pull lower layers into view.

  """

  def review_context(%Repository{} = repository, %PullRequest{} = pull_request) do

    case active_entry_for_pull_request(pull_request) do

      nil ->

        {:error, :not_stacked}

      %StackEntry{} = entry ->

        stack =

          Stack

          |> Repo.get!(entry.stack_id)

          |> Repo.preload(entries: active_entries_query())

        entry = Enum.find(stack.entries, &(&1.id == entry.id))

        parent_ref = parent_ref(stack, entry)

        {:ok,

         %{

           stack: stack,

           entry: entry,

           position: entry.position,

           size: length(stack.entries),

           layer_range: {entry.boundary_oid, entry.observed_head_oid},

           cumulative_range: cumulative_range(repository, stack, entry),

           boundary_state: boundary_state(repository, entry, parent_ref)

         }}

    end

  end

  defp parent_ref(stack, %StackEntry{position: 1}), do: stack.trunk_ref

  defp parent_ref(stack, entry) do

    parent = Enum.find(stack.entries, &(&1.position == entry.position - 1))

    parent.pull_request.head_ref

  end

  defp cumulative_range(repository, stack, entry) do

    case Browse.resolve_commit(repository, stack.trunk_ref) do

      {:ok, trunk_tip} -> {trunk_tip, entry.observed_head_oid}

      _other -> nil

    end

  end

  defp boundary_state(repository, entry, parent_ref) do

    with {:ok, parent_tip} <- GitPlane.resolve_commit(repository.storage_key, parent_ref),

         {:ok, reachable} <-

           GitPlane.ancestor?(repository.storage_key, entry.boundary_oid, parent_tip) do

      if reachable, do: :intact, else: :stale

    else

      _other -> :unknown

    end

  end

  def get_by_number!(%Repository{id: repository_id}, number) when is_integer(number) do

    Stack

    |> Repo.get_by!(repository_id: repository_id, number: number)

defmodule OpenAgentsWeb.PullRequestShowLive do

  @moduledoc "Shows one repository pull request."

  @moduledoc """

  Shows one repository pull request.

  A stacked pull request presents its own layer as the primary review diff

  — the stored boundary OID to the observed head OID — and offers an

  explicit cumulative preview from the current trunk tip. When a parent

  rewrite makes the stored boundary unreachable, the page explains the

  stale boundary and offers a restack action instead of silently rendering

  lower layers inside the layer diff.

  """

  use OpenAgentsWeb, :live_view

  alias OpenAgents.Diff

  alias OpenAgents.Forge.Browse

  alias OpenAgents.PullRequests

  alias OpenAgents.Repositories

  alias OpenAgents.Stacks

  alias OpenAgentsWeb.RepositoryAccess

  def mount(%{"owner" => owner, "repo" => repo, "number" => number}, _session, socket) do

    repository = visible_repository!(owner, repo, socket.assigns.current_user)

    pull_request = PullRequests.get_by_number!(repository, String.to_integer(number))

    stack_context =

      case Stacks.review_context(repository, pull_request) do

        {:ok, context} -> context

        {:error, :not_stacked} -> nil

      end

    {:ok,

     socket

     |> assign(:current_scope, socket.assigns[:current_scope])

     |> assign(:owner, owner)

     |> assign(:repo, repo)

     |> assign(:repository, repository)

     |> assign(:pull_request, pull_request)}

     |> assign(:pull_request, pull_request)

     |> assign(:stack_context, stack_context)

     |> assign(

       :diff_readable,

       RepositoryAccess.full_source?(repository, socket.assigns.current_user)

     )}

  end

  def handle_params(params, _uri, socket) do

    view = if params["view"] == "cumulative", do: :cumulative, else: :layer

    {:noreply, socket |> assign(:stack_view, view) |> assign_stack_diff()}

  end

  defp assign_stack_diff(%{assigns: %{stack_context: nil}} = socket) do

    socket |> assign(:diff_files, []) |> assign(:diff_truncated, false)

  end

  defp assign_stack_diff(%{assigns: assigns} = socket) do

    range =

      case assigns.stack_view do

        :cumulative -> assigns.stack_context.cumulative_range

        :layer -> layer_range_if_intact(assigns.stack_context)

      end

    {diff, truncated} =

      with true <- assigns.diff_readable,

           {base, head} <- range,

           {:ok, diff, truncated} <- Browse.diff_range(assigns.repository, base, head) do

        {diff, truncated}

      else

        _unavailable -> {nil, false}

      end

    socket

    |> assign(:diff_files, Diff.parse(diff))

    |> assign(:diff_truncated, truncated)

  end

  defp layer_range_if_intact(%{boundary_state: :stale}), do: nil

  defp layer_range_if_intact(context), do: context.layer_range

  def render(assigns) do

    ~H"""

    <Layouts.app

            <div class="mt-8 rounded-xl border border-border bg-card p-6 whitespace-pre-wrap text-foreground">

              {@pull_request.issue.body || "No description provided."}

            </div>

            <section :if={@stack_context} id="stack-review" class="mt-8">

              <div class="flex flex-wrap items-center gap-3">

                <h2 class="text-lg font-semibold text-foreground">

                  Stack #{@stack_context.stack.number} · layer {@stack_context.position} of {@stack_context.size}

                </h2>

                <.badge variant={

                  if(@stack_context.stack.health == "healthy", do: :success, else: :warning)

                }>

                  {@stack_context.stack.health}

                </.badge>

              </div>

              <nav class="mt-4 flex gap-2" aria-label="Stack diff views">

                <.button

                  id="stack-view-layer"

                  patch={~p"/#{@owner}/#{@repo}/pulls/#{@pull_request.issue.number}?view=layer"}

                  variant={if @stack_view == :layer, do: :primary, else: :outline}

                  size={:sm}

                >

                  Layer diff

                </.button>

                <.button

                  id="stack-view-cumulative"

                  patch={~p"/#{@owner}/#{@repo}/pulls/#{@pull_request.issue.number}?view=cumulative"}

                  variant={if @stack_view == :cumulative, do: :primary, else: :outline}

                  size={:sm}

                >

                  Cumulative preview

                </.button>

              </nav>

              <p

                :if={@stack_view == :layer}

                id="stack-layer-range"

                class="mt-3 text-sm text-muted-foreground"

              >

                This layer only: {short(elem(@stack_context.layer_range, 0))} → {short(

                  elem(@stack_context.layer_range, 1)

                )}.

              </p>

              <p

                :if={@stack_view == :cumulative and @stack_context.cumulative_range}

                id="stack-cumulative-range"

                class="mt-3 text-sm text-muted-foreground"

              >

                Everything through position {@stack_context.position}: {short(

                  elem(@stack_context.cumulative_range, 0)

                )} → {short(elem(@stack_context.cumulative_range, 1))}.

              </p>

              <.alert

                :if={@stack_view == :layer and @stack_context.boundary_state == :stale}

                id="stack-stale-boundary"

                variant={:warning}

                appearance={:notice}

                label="This layer is based on an outdated parent commit"

                class="mt-4"

              >

                A lower branch was rewritten, so the stored review boundary no longer

                matches the parent branch. Rebase the stack to restore the intended

                review boundary.

                <:action>

                  <.button id="stack-restack-action" variant={:outline} size={:sm} disabled>

                    Rebase the stack

                  </.button>

                </:action>

              </.alert>

              <div :if={@diff_files != []} class="mt-6 space-y-4">

                <.diff_file :for={file <- @diff_files} file={file} />

              </div>

              <p :if={@diff_truncated} class="mt-3 text-sm text-muted-foreground">

                The diff is truncated.

              </p>

            </section>

          </article>

        </.repo_view>

      </main>

    """

  end

  defp short(sha), do: String.slice(sha, 0, 12)

  defp visible_repository!(owner, repo, user) do

    Repositories.get_visible_by_path!(owner, repo, user)

  rescue

defmodule OpenAgentsWeb.PullRequestLiveTest do

  use OpenAgentsWeb.ConnCase

  import Phoenix.LiveViewTest

  import OpenAgents.AccountsFixtures

  import OpenAgents.IssuesFixtures

  alias OpenAgents.Forge.Repos

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repo

  alias OpenAgents.Stacks

  test "the pull request list links to a valid browser detail page", %{conn: conn} do

    target = repository_fixture()

    assert has_element?(show, "#pull-request-show")

  end

  describe "stacked pull request review" do

    setup do

      base =

        Path.join(

          System.tmp_dir!(),

          "pull-request-show-#{System.unique_integer([:positive])}"

        )

      previous_data = Application.get_env(:openagents, :forge_data_dir)

      previous_wal = Application.get_env(:openagents, :forge_wal_dir)

      Application.put_env(:openagents, :forge_data_dir, Path.join(base, "data"))

      Application.put_env(:openagents, :forge_wal_dir, Path.join(base, "wal"))

      on_exit(fn ->

        restore_env(:forge_data_dir, previous_data)

        restore_env(:forge_wal_dir, previous_wal)

        File.rm_rf(base)

      end)

      repository = repository_fixture()

      oids = seed_chain(repository, ["layer-1", "layer-2"])

      pull_requests = pull_request_chain(repository, oids, ["layer-1", "layer-2"])

      actor = repository_user_fixture("stack-reviewer")

      {:ok, _stack} = Stacks.create(repository, pull_requests, actor)

      %{repository: repository, oids: oids, pull_requests: pull_requests}

    end

    test "the layer diff runs from the boundary OID to the observed head OID", %{

      conn: conn,

      repository: repository,

      oids: oids,

      pull_requests: pull_requests

    } do

      top = Enum.at(pull_requests, 1)

      {:ok, show, html} = live(conn, pull_path(repository, top))

      assert has_element?(show, "#stack-review")

      assert element(show, "#stack-layer-range") |> render() =~

               "#{short(oids["layer-1"])} → #{short(oids["layer-2"])}"

      assert html =~ "layer-2.md"

      refute html =~ "layer-1.md"

      refute has_element?(show, "#stack-stale-boundary")

    end

    test "the cumulative preview runs from the trunk tip to the observed head OID", %{

      conn: conn,

      repository: repository,

      oids: oids,

      pull_requests: pull_requests

    } do

      top = Enum.at(pull_requests, 1)

      {:ok, show, html} = live(conn, pull_path(repository, top) <> "?view=cumulative")

      assert element(show, "#stack-cumulative-range") |> render() =~

               "Everything through position 2"

      assert element(show, "#stack-cumulative-range") |> render() =~

               "#{short(oids["main"])} → #{short(oids["layer-2"])}"

      assert html =~ "layer-1.md"

      assert html =~ "layer-2.md"

    end

    test "a parent rewrite shows the stale boundary state instead of lower layers", %{

      conn: conn,

      repository: repository,

      oids: oids,

      pull_requests: pull_requests

    } do

      path = Repos.bare_path(repository.storage_key)

      rewritten =

        commit(path, oids["main"], "Rewritten layer", ["README.md", "rewritten.md"])

      {_, 0} = Repos.git(path, ["update-ref", "refs/heads/layer-1", rewritten])

      top = Enum.at(pull_requests, 1)

      {:ok, show, html} = live(conn, pull_path(repository, top))

      assert has_element?(show, "#stack-stale-boundary")

      assert has_element?(show, "#stack-restack-action")

      assert render(show) =~ "based on an outdated parent commit"

      refute html =~ "layer-1.md"

      refute html =~ "layer-2.md"

    end

  end

  defp pull_path(repository, pull_request) do

    "/#{repository.owner}/#{repository.name}/pulls/#{pull_request.issue.number}"

  end

  defp short(oid), do: String.slice(oid, 0, 12)

  defp seed_chain(repository, branches) do

    path = Repos.ensure_repo!(repository.storage_key, repository.default_branch)

    main = commit(path, nil, "Seed repository", ["README.md"])

    {_, 0} = Repos.git(path, ["update-ref", "refs/heads/main", main])

    {oids, _files} =

      Enum.reduce(branches, {%{"main" => main}, ["README.md"]}, fn branch, {oids, files} ->

        parent = Map.fetch!(oids, previous_branch(branches, branch))

        files = files ++ ["#{branch}.md"]

        oid = commit(path, parent, "Layer #{branch}", files)

        {_, 0} = Repos.git(path, ["update-ref", "refs/heads/#{branch}", oid])

        {Map.put(oids, branch, oid), files}

      end)

    oids

  end

  defp previous_branch(branches, branch) do

    index = Enum.find_index(branches, &(&1 == branch))

    Enum.at(["main" | branches], index)

  end

  defp commit(path, parent, message, files) do

    tree_input =

      Enum.map_join(files, fn file ->

        blob = git!(path, ["hash-object", "-w", "--stdin"], "#{file}\n")

        "100644 blob #{blob}\t#{file}\n"

      end)

    tree = git!(path, ["mktree"], tree_input)

    parent_args = if parent, do: ["-p", parent], else: []

    git!(path, ["commit-tree", tree] ++ parent_args ++ ["-m", message], "",

      env: [

        {"GIT_AUTHOR_NAME", "Test Author"},

        {"GIT_AUTHOR_EMAIL", "author@example.test"},

        {"GIT_COMMITTER_NAME", "Test Author"},

        {"GIT_COMMITTER_EMAIL", "author@example.test"}

      ]

    )

  end

  defp pull_request_chain(repository, oids, branches) do

    branches

    |> Enum.with_index()

    |> Enum.map(fn {branch, index} ->

      base = Enum.at(["main" | branches], index)

      pull_request(repository, branch, base, oids[base], oids[branch])

    end)

  end

  defp pull_request(repository, head_ref, base_ref, base_sha, head_sha) do

    issue = issue_fixture(repository, %{title: "PR #{head_ref}"})

    {:ok, pull_request} =

      %PullRequest{}

      |> PullRequest.changeset(%{

        repository_id: repository.id,

        issue_id: issue.id,

        head_repository_id: repository.id,

        head_ref: head_ref,

        head_sha: head_sha,

        base_ref: base_ref,

        base_sha: base_sha,

        state: "open"

      })

      |> Repo.insert()

    Repo.preload(pull_request, :issue)

  end

  defp git!(git_dir, args, input, options \\ []) do

    input_path =

      Path.join(

        System.tmp_dir!(),

        "pull-request-show-input-#{System.unique_integer([:positive])}"

      )

    File.write!(input_path, input)

    try do

      {output, 0} =

        System.cmd(

          "sh",

          ["-c", ~s(exec git --git-dir "$GIT_DIR" "$@" < "$INPUT"), "sh"] ++ args,

          env: [{"GIT_DIR", git_dir}, {"INPUT", input_path}] ++ Keyword.get(options, :env, [])

        )

      String.trim(output)

    after

      File.rm(input_path)

    end

  end

  defp restore_env(key, nil), do: Application.delete_env(:openagents, key)

  defp restore_env(key, value), do: Application.put_env(:openagents, key, value)

end