[CI] PR change report: narrow agent to function-range identification only

The agent step on auto_diff.cpp (a 2540-LoC file with a 690-line diff) was
hanging on claude-4.6-opus-high-thinking for 15+ minutes because the agent
was doing both function identification AND line counting AND output
formatting, with the slowest model variant available.

Refactor: the agent now produces ONLY a JSONL stream of function ranges
(name + HEAD/base line bounds), and only for functions whose body
intersects a diff hunk. Everything else -- per-function totals, +/-
attribution, and the report shape -- is computed deterministically from
the diff and the HEAD/base files in `render_report.py`.

To support this:
  - `build_inputs.py` now also dumps `head/<path>` (so `render_report.py`
    is self-contained), and writes `touched_ranges.txt` -- per-file HEAD
    and base hunk ranges -- as a hint so the agent only has to read code
    near touched regions.
  - `render_report.py` consumes phase-1 outputs + the agent's JSONL,
    computes total/added/removed per function (using the same
    code-line-set definition as the file-level totals), and emits the
    final report.txt.
  - The workflow agent step is rewritten with the narrow JSONL prompt,
    and the model is dropped from `claude-4.6-opus-high-thinking` to
    `claude-4.6-sonnet-thinking` (function identification is structural
    pattern-matching, not deep reasoning).
  - `touched_ranges.txt` and `function_ranges.jsonl` are uploaded with
    the existing artifacts for debuggability.

Verified locally with synthetic JSONL on PR #621's auto_diff.cpp diff
(NEW + modified functions both render correctly) and on the empty-JSONL
case (file headers preserved, with a "no per-function attribution
available" note so the report is still useful if the agent fails).

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: hughperkins

.github/workflows/pr_change_report.yml

@@ -61,61 +61,72 @@ jobs:
           curl https://cursor.com/install -fsS | bash
           echo "$HOME/.cursor/bin" >> $GITHUB_PATH
 
-      - name: Generate per-function breakdown with Cursor agent
+      - name: Identify changed function ranges with Cursor agent
         if: steps.inputs.outputs.skip != 'true'
         env:
           CURSOR_API_KEY: ${{ secrets.CURSOR_KEY_HUGH }}
         run: |
           agent -p "$(cat <<'PROMPT'
-          You are producing a PR change report. Inputs are under /tmp/pr_change_report/ :
-            - summary.json     : list of {"path","language","total","added","removed"} for each
-                                 changed source file. Numbers are NON-comment, NON-blank code
-                                 lines (Python multi-line strings and docstrings also excluded),
-                                 computed deterministically. Treat them as authoritative.
-            - report_header.md : exact file-header lines you must use verbatim, e.g.
-                                   foo.py 700 +63 -5
-                                   blah.cpp 2000 +45 -20
-            - file_list.txt    : changed paths, one per line, in the order you must emit.
-            - diffs/<path>.diff : per-file unified diff vs merge-base.
-            - base/<path>      : full base content of that file (missing if newly added).
-          The HEAD content of each file is in the workspace (current checkout) at the same path.
-
-          Your task: for each path in file_list.txt, in order, emit:
-            1. The exact file-header line from report_header.md, verbatim, on its own line.
-            2. Indented (4 spaces) per-function lines, one per function/method that was added
-               or modified by this PR. Format:
-                  <name>() NEW +<added>                 (function did not exist on base)
-                  <name>() <total> +<added>             (only added code lines)
-                  <name>() <total> -<removed>           (only removed code lines)
-                  <name>() <total> +<added> -<removed>  (both)
-               where:
-                 - <total>   = current LoC of the function in HEAD (NON-comment, NON-blank;
-                               for Python, also exclude docstrings and multi-line-string-only
-                               continuation lines).
-                 - <added>   = code lines this function gained.
-                 - <removed> = code lines this function lost.
-               For top-level statements that are not inside a function/class, group them
-               under the synthetic name `<module>()`.
-            3. After the last function line for a file, a single blank line before the next
-               file's header.
-
-          Constraints:
-            - Use function names as they appear in source. C++ class methods are
-              "ClassName::method". Free functions are just "func". Lambdas inside another
-              function may be skipped or grouped under their enclosing function.
-            - Only list functions whose +/- counts are non-zero. Do not include unchanged
-              functions.
-            - Do not invent functions that do not exist in HEAD or base.
-            - Sums of per-function +/- counts SHOULD MATCH the file-level +/- counts in
-              report_header.md. Small drift (1-2 lines) is acceptable for unusual hunks
-              (e.g. straddling block-comment boundaries) but if drift exceeds 5 lines on
-              either side, add ONE line below that file's section, indented 4 spaces:
-                  # note: per-function +/- differs from file totals by +N -M
-            - Output ONLY the report. No preamble, no headings, no closing remarks, no
-              code fences, no explanations.
+          You are identifying which functions were touched by a PR. Line counts and +/-
+          attribution are computed deterministically AFTER your output, so do NOT count
+          lines yourself.
+
+          Inputs under /tmp/pr_change_report/ :
+            - file_list.txt        changed source paths (.py / .c / .cc / .cpp / .h / .hpp /
+                                   .cu), one per line.
+            - touched_ranges.txt   per-file, the line-number ranges in HEAD and base that the
+                                   diff hunks cover. This tells you exactly where to look --
+                                   you should only need to inspect lines inside (or close to)
+                                   these ranges, not the whole file.
+            - diffs/<path>.diff    per-file unified diff vs merge-base.
+            - head/<path>          full HEAD content of that file (also reachable from the
+                                   workspace at the same path).
+            - base/<path>          full base content (missing if the file is newly added).
+
+          For each file in file_list.txt, identify every function or method whose body
+          contains at least one ``+`` or ``-`` line in the diff. Emit ONE JSON object per
+          such function on its own line, with these keys:
+            path : the file path, exactly as it appears in file_list.txt.
+            name : the function or method name. C++ class methods MUST be
+                   "ClassName::method"; free functions are just "func"; top-level statements
+                   that are not inside any function/class go under the synthetic name
+                   "<module>".
+            head : [start_line, end_line] in HEAD, both 1-indexed and inclusive (signature
+                   line through closing brace / dedent), or null if the function was
+                   DELETED by this PR.
+            base : [start_line, end_line] in the base version, or null if the function was
+                   NEWLY added by this PR.
+
+          Rules:
+            - Only emit functions that overlap a hunk in touched_ranges.txt. Skip every
+              other function in the file.
+            - For functions modified by this PR, both head and base are filled (their line
+              ranges may differ).
+            - Anonymous lambdas inside another function are NOT separate functions; their
+              touched lines belong to the enclosing function.
+            - The end_line of a function is the line of the closing brace (C/C++) or the
+              last indented body line (Python), inclusive.
+            - Use the touched_ranges.txt hints to narrow your reading -- you should not need
+              to read whole large files. Read only enough HEAD and base context to bracket
+              each touched function with confidence.
+
+          Output: JSON Lines. ONE JSON object per line. Nothing else. NO code fences, NO
+          preamble, NO closing remarks, NO commentary, NO blank lines between objects.
           PROMPT
-          )" --model claude-4.6-opus-high-thinking --mode ask --output-format text --trust \
-            > /tmp/pr_change_report/report.txt
+          )" --model claude-4.6-sonnet-thinking --mode ask --output-format text --trust \
+            > /tmp/pr_change_report/function_ranges.jsonl
+
+          echo "----- function_ranges.jsonl -----"
+          cat /tmp/pr_change_report/function_ranges.jsonl
+          echo "---------------------------------"
+
+      - name: Render report.txt deterministically
+        if: steps.inputs.outputs.skip != 'true'
+        run: |
+          python .github/workflows/scripts_new/pr_change_report/render_report.py \
+            --output-dir /tmp/pr_change_report \
+            --function-ranges /tmp/pr_change_report/function_ranges.jsonl \
+            --output /tmp/pr_change_report/report.txt
 
           echo "----- report.txt -----"
           cat /tmp/pr_change_report/report.txt
@@ -158,6 +169,8 @@ jobs:
             /tmp/pr_change_report/report_comment.md
             /tmp/pr_change_report/summary.json
             /tmp/pr_change_report/report_header.md
+            /tmp/pr_change_report/touched_ranges.txt
+            /tmp/pr_change_report/function_ranges.jsonl
 
       - name: Publish PR change report Check
         if: steps.inputs.outputs.skip != 'true' && github.event_name == 'pull_request'

.github/workflows/scripts_new/pr_change_report/build_inputs.py

@@ -8,6 +8,7 @@
   ``<output_dir>/report_header.md``    pre-formatted file-header lines (verbatim for the report)
   ``<output_dir>/report_comment.md``   compact PR-comment markdown (table + totals line)
   ``<output_dir>/diffs/<path>.diff``   per-file unified diff vs. merge-base
+  ``<output_dir>/head/<path>``         HEAD content of the file (always present)
   ``<output_dir>/base/<path>``         file content at merge-base (absent for newly added files)
 
 ``total`` is the number of code lines in the HEAD version of the file. ``added`` and ``removed`` are
@@ -203,15 +204,15 @@ def code_line_set(src: str, language: str) -> set[int]:
 HUNK_RE = re.compile(r"@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
 
 
-def diff_added_removed(diff_text: str, head_codes: set[int], base_codes: set[int]) -> tuple[int, int]:
-    """Count code-line additions and removals in a unified diff.
+def diff_changed_line_numbers(diff_text: str) -> tuple[list[int], list[int]]:
+    """Walk a unified diff and return ``(added_new_line_nos, removed_old_line_nos)``.
 
-    For each ``+`` line, the line number in the new file must be in ``head_codes``; for each ``-``
-    line, the line number in the old file must be in ``base_codes``. This way block comments are
-    excluded correctly because the code-line sets were computed with full block-comment stripping.
+    Each list contains the 1-indexed line number that each ``+`` (or ``-``) line maps to in the
+    new (or old) file -- one entry per diff line. Hunk headers, file headers and the
+    ``\\ No newline at end of file`` marker are skipped.
     """
-    added = 0
-    removed = 0
+    added: list[int] = []
+    removed: list[int] = []
     new_no = 0
     old_no = 0
     in_hunk = False
@@ -230,12 +231,10 @@ def diff_added_removed(diff_text: str, head_codes: set[int], base_codes: set[int
         if not in_hunk:
             continue
         if line.startswith("+"):
-            if new_no in head_codes:
-                added += 1
+            added.append(new_no)
             new_no += 1
         elif line.startswith("-"):
-            if old_no in base_codes:
-                removed += 1
+            removed.append(old_no)
             old_no += 1
         elif line.startswith(" "):
             new_no += 1
@@ -245,6 +244,72 @@ def diff_added_removed(diff_text: str, head_codes: set[int], base_codes: set[int
     return added, removed
 
 
+def diff_added_removed(diff_text: str, head_codes: set[int], base_codes: set[int]) -> tuple[int, int]:
+    """Count code-line additions and removals in a unified diff.
+
+    A ``+`` line is counted if its new-file line number is in ``head_codes``; a ``-`` line is
+    counted if its old-file line number is in ``base_codes``. This excludes block-comment
+    content correctly because the code-line sets were computed with full comment stripping.
+    """
+    added_lines, removed_lines = diff_changed_line_numbers(diff_text)
+    added = sum(1 for ln in added_lines if ln in head_codes)
+    removed = sum(1 for ln in removed_lines if ln in base_codes)
+    return added, removed
+
+
+def diff_touched_ranges(diff_text: str) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]:
+    """Return the (head_ranges, base_ranges) covered by hunks of ``diff_text``.
+
+    Each range is ``(start_line, end_line)`` 1-indexed inclusive. The head ranges cover the
+    new-file line numbers spanned by each hunk's ``+``/context lines; base ranges cover the
+    old-file line numbers spanned by ``-``/context lines. Useful as a hint to the agent about
+    where to look for changed functions without scanning the whole file.
+    """
+    head_ranges: list[tuple[int, int]] = []
+    base_ranges: list[tuple[int, int]] = []
+    new_no = 0
+    old_no = 0
+    head_start = base_start = None
+    head_last = base_last = None
+    for line in diff_text.splitlines():
+        if line.startswith("+++") or line.startswith("---"):
+            continue
+        if line.startswith("@@"):
+            if head_start is not None:
+                head_ranges.append((head_start, head_last))
+            if base_start is not None:
+                base_ranges.append((base_start, base_last))
+            m = HUNK_RE.match(line)
+            if not m:
+                head_start = base_start = head_last = base_last = None
+                continue
+            old_no = int(m.group(1))
+            new_no = int(m.group(3))
+            head_start = new_no
+            base_start = old_no
+            head_last = new_no - 1
+            base_last = old_no - 1
+            continue
+        if line.startswith("+"):
+            head_last = new_no
+            new_no += 1
+        elif line.startswith("-"):
+            base_last = old_no
+            old_no += 1
+        elif line.startswith(" "):
+            head_last = new_no
+            base_last = old_no
+            new_no += 1
+            old_no += 1
+        elif line.startswith("\\"):
+            continue
+    if head_start is not None and head_last >= head_start:
+        head_ranges.append((head_start, head_last))
+    if base_start is not None and base_last >= base_start:
+        base_ranges.append((base_start, base_last))
+    return head_ranges, base_ranges
+
+
 @dataclass
 class FileSummary:
     path: str
@@ -306,6 +371,7 @@ def main() -> int:
 
     output_dir = Path(args.output_dir)
     diffs_dir = output_dir / "diffs"
+    head_dir = output_dir / "head"
     base_dir = output_dir / "base"
     output_dir.mkdir(parents=True, exist_ok=True)
 
@@ -342,6 +408,7 @@ def main() -> int:
         added, removed = diff_added_removed(diff_text, head_codes, base_codes)
 
         write_file(diffs_dir / f"{path}.diff", diff_text)
+        write_file(head_dir / path, head_content)
         if base_content:
             write_file(base_dir / path, base_content)
 
@@ -361,6 +428,15 @@ def main() -> int:
 
     (output_dir / "report_comment.md").write_text(render_comment_markdown(summaries, args.commit_hash))
 
+    touched_lines = []
+    for s in summaries:
+        diff_text = (diffs_dir / f"{s.path}.diff").read_text()
+        head_ranges, base_ranges = diff_touched_ranges(diff_text)
+        head_str = ", ".join(f"{a}-{b}" for a, b in head_ranges) or "(none)"
+        base_str = ", ".join(f"{a}-{b}" for a, b in base_ranges) or "(none)"
+        touched_lines.append(f"{s.path}\n  head hunks: {head_str}\n  base hunks: {base_str}")
+    (output_dir / "touched_ranges.txt").write_text("\n".join(touched_lines) + ("\n" if touched_lines else ""))
+
     print(f"Wrote summaries for {len(summaries)} file(s) to {output_dir}")
     if summaries:
         print()