Function capBodyToGithubLimit

packages/cli/src/lib/issue-body.ts:108–176

(
    body: string,
    maxBytes: number = MAX_GITHUB_BODY_BYTES,
)

 * `body` payloads above the limit).
 */
export function capBodyToGithubLimit(
    body: string,
    maxBytes: number = MAX_GITHUB_BODY_BYTES,
): string {
    if (Buffer.byteLength(body, "utf8") <= maxBytes) return body;

    // Find the main log fence (we use a stable heading that the bundlers
    // always emit below). We don't search for the closing ``` directly
    // because there are several fenced blocks; instead we anchor on the
    // heading line and assume the fence pair is the next ``` / ``` after
    // it (the bundler's structure guarantees this).
    const heading = "## Log (last";
    const headingIdx = body.indexOf(heading);
    if (headingIdx === -1) {
        // No main log section to shrink — fall back to a raw byte truncation
        // with a marker. This shouldn't happen with the bundlers we control,
        // but keeps the function defensive for callers passing arbitrary
        // markdown.
        const marker = "\n\n[truncated for GitHub 64KB limit]\n";
        const markerBytes = Buffer.byteLength(marker, "utf8");
        // Slice the body to a code-point boundary so we never split a multi-
        // byte UTF-8 character. Naive `Buffer.subarray(...).toString("utf8")`
        // would replace any half-codepoint at the cut with U+FFFD (3 bytes),
        // pushing the output OVER the requested budget.
        return truncateToByteBudget(body, maxBytes - markerBytes) + marker;
    }
    const fenceOpenIdx = body.indexOf("\n```", headingIdx);
    if (fenceOpenIdx === -1) return body; // malformed; pass through unchanged
    const logStart = fenceOpenIdx + "\n```\n".length;
    const fenceCloseIdx = body.indexOf("\n```", logStart);
    if (fenceCloseIdx === -1) return body;

    const head = body.slice(0, logStart);
    const log = body.slice(logStart, fenceCloseIdx);
    const tail = body.slice(fenceCloseIdx);

    const overheadBytes = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
    // Reserve room for the truncation marker that we'll prepend to the log
    // body so the agent / human reading the issue knows lines were dropped.
    const truncationMarker = "[truncated for GitHub 64KB limit — older log lines dropped]\n";
    const markerBytes = Buffer.byteLength(truncationMarker, "utf8");
    const logBudget = maxBytes - overheadBytes - markerBytes;
    if (logBudget <= 0) {
        // Even with no log content we'd be over budget. Drop the log block
        // entirely (keep the heading + a stub marker) so the rest survives.
        return `${head}${truncationMarker}${tail}`;
    }

    // Drop oldest lines (from the top) until what's left fits the budget.
    // We split on newlines to preserve line boundaries; binary truncation
    // would corrupt the final line.
    const lines = log.split("\n");
    let keepLines = lines;
    let kept = keepLines.join("\n");
    while (Buffer.byteLength(kept, "utf8") > logBudget && keepLines.length > 1) {
        // Drop ~5% from the top each iteration for fast convergence on
        // very-oversized inputs. Caps at "drop at least one line".
        const dropCount = Math.max(1, Math.floor(keepLines.length * 0.05));