better-review 0.1.0 → 0.3.0

package/README.md

@@ -50,8 +50,8 @@ Puis « Repos suivis » : ajouter des repos (`owner/repo`) ou des orgs / comptes
 
 ## Raccourcis (vue PR)
 
-`j`/`k` fichier · `n`/`p` hunk · `]`/`[` thread non résolu · `v` fichier vu (Focus : puis fichier non vu
-suivant) · `h` hunk vu · `r` répondre · `x` résoudre · `m` continu/focus · `u` côte à côte/unifié ·
+`j`/`k` fichier · `n`/`p` hunk · `]`/`[` thread non résolu · `v` fichier vu puis fichier suivant (Focus : fichier non
+vu suivant), comme le bouton « Vu » d'un fichier · `h` hunk vu · `r` répondre · `x` résoudre · `m` continu/focus · `u` côte à côte/unifié ·
 `t` conversations · `d` description · `f` panneau fichiers · `Maj+S` review · `i` inbox · `Ctrl+K` aller à une PR ·
 `?` aide.
 
@@ -61,24 +61,27 @@ pour le fichier entier. Chaque commentaire part seul ou dans la review en attent
 
 ## Naviguer dans les fichiers
 
-Le panneau de gauche (520 px, masquable avec `f`) propose quatre vues :
+Le panneau de gauche (360 px, masquable avec `f`) propose trois vues. **La vue choisie fixe l'ordre des fichiers** :
+le diff, `j`/`k`, le mode Focus et « Vu → fichier suivant » suivent l'ordre affiché (les filtres masquent des lignes
+sans changer l'ordre).
 
-| Vue   | Ce qu'elle montre                                                                                                            |
-| ----- | ---------------------------------------------------------------------------------------------------------------------------- |
-| Liste | Fichiers par dossier ou triés par taille, barre +/− par fichier                                                              |
-| Arbre | Dossiers repliables avec le total des changements, les fichiers vus et les threads ouverts                                   |
-| Carte | Treemap : surface ∝ lignes modifiées, couleur ajouts → suppressions, fichiers vus estompés ; clic sur un dossier pour zoomer |
-| Liens | Voisinage du fichier courant (ce qu'il utilise → fichier → ce qui l'utilise), liste en ordre de lecture, graphe plein écran  |
+| Vue   | Ce qu'elle montre (et l'ordre qu'elle impose)                                                                  |
+| ----- | -------------------------------------------------------------------------------------------------------------- |
+| Liste | Fichiers par chemin, groupés par dossier (A→Z), ou du plus gros au plus petit (Taille) ; barre +/− par fichier |
+| Arbre | Dossiers repliables (sous-dossiers avant fichiers, A→Z ou Taille) avec changements, fichiers vus, threads      |
+| Liens | Fichiers en ordre de lecture « base d'abord », nombre d'imports / d'utilisateurs, graphe plein écran           |
 
 Les liens sont calculés côté serveur sur le contenu complet des fichiers au head de la PR : AST TypeScript pour
 TS/JS (y compris `.js` → `.ts`, `require`, `import()`), règles dédiées pour Python, CSS/SCSS/Less, Go, Java/Kotlin,
 C/C++, Rust, Ruby, Vue/Svelte. Les mentions (nom de fichier en CamelCase, ou nom avec extension, ou chemin) couvrent
 la doc et les autres langages. Les alias `tsconfig` `paths` autres que `@/`, `~/`, `#` ne sont pas résolus.
 
-**Ordre « Base d'abord »** (barre de la PR, à côté de Continu / Focus) : le diff, `j`/`k` et le mode Focus suivent un
-ordre topologique, chaque fichier après ceux qu'il importe ou mentionne, les plus utilisés en premier, les cycles
-départagés de la même façon et les fichiers sans lien à la fin. On relit la PR de ses fondations vers ce qui les
-assemble.
+**Ordre « base d'abord »** (vue Liens) : ordre topologique, chaque fichier après ceux qu'il importe ou mentionne, les
+plus utilisés en premier, les cycles départagés de la même façon et les fichiers sans lien à la fin. On relit la PR de
+ses fondations vers ce qui les assemble.
+
+**Voisinage** (onglet du panneau de droite, 520 px, quelle que soit la vue de gauche) : graphe du fichier courant, ce
+qu'il utilise → fichier → ce qui l'utilise, avec tous ses voisins ; clic sur un voisin pour l'ouvrir.
 
 **Monorepos** : chaque dossier contenant un manifeste (`package.json`, `pyproject.toml`, `setup.py`, `go.mod`,
 `Cargo.toml`, `pom.xml`, `build.gradle`, `composer.json`) est un package ; à partir de deux, l'ordre devient
@@ -91,7 +94,7 @@ monorepo et les dépendances entre packages (option « Autres packages du monore
 packages qui contiennent des fichiers modifiés (et les liens entre eux), le reste en gris. Le graphe de voisinage
 mélange fichiers et packages : à gauche les packages que le fichier importe par leur nom, à droite les packages qui
 dépendent de son package (quand aucun de leurs fichiers n'y figure déjà), mêmes couleurs ; un voisin d'un autre package
-porte le nom de son package, et un clic sur un package modifié ouvre son premier fichier dans l'ordre de lecture.
+porte le nom de son package, et un clic sur un package modifié ouvre son premier fichier dans l'ordre courant.
 
 La description de la PR s'ouvre dans l'onglet « Description » du panneau de droite.
 
@@ -105,6 +108,11 @@ packages/shared schémas zod, parseur de diff unifié (empreinte de hunk partag
 ```
 
 - Les diffs sont demandés entre deux SHA (immuables) et mis en cache définitivement.
+- La coloration syntaxique porte sur le fichier entier (blobs désignés par les lignes `index` du diff, mis en cache
+  définitivement) : un commentaire ou une chaîne ouvert hors d'un hunk est coloré correctement. Fichier trop gros ou
+  indisponible : seules les lignes du diff sont colorées.
+- Un commentaire, une réponse ou un nouveau thread s'affiche dès la réponse de GitHub ; la PR est rechargée ensuite en
+  arrière-plan.
 - L'inbox fait une recherche « ids seulement » par section puis charge chaque PR une seule fois
   (≈ 1 point de quota GraphQL par PR).
 - Une PR ouverte est surveillée toutes les 30 s, l'inbox toutes les 2 min ; un changement côté GitHub

package/dist/cli.js

@@ -5852,6 +5852,8 @@ function parseUnifiedDiff(text) {
         status: "modified",
         binary: false,
         truncated: false,
+        oldBlob: null,
+        newBlob: null,
         additions: 0,
         deletions: 0,
         hunks: []
@@ -5887,7 +5889,12 @@ function parseUnifiedDiff(text) {
       f.path = unquote(line.slice("rename to ".length));
       f.status = "renamed";
     } else if (line.startsWith("Binary files ") || line === "GIT binary patch") f.binary = true;
-    else if (line.startsWith("--- ")) {
+    else if (line.startsWith("index ")) {
+      const ids = /^index ([0-9a-f]+)\.\.([0-9a-f]+)/.exec(line);
+      const blob = (id) => id === void 0 || /^0+$/.test(id) ? null : id;
+      f.oldBlob = blob(ids?.[1]);
+      f.newBlob = blob(ids?.[2]);
+    } else if (line.startsWith("--- ")) {
       const p = line.slice(4);
       if (p !== "/dev/null") f.oldPath = stripPrefix(p);
     } else if (line.startsWith("+++ ")) {
@@ -25774,153 +25781,6 @@ var GitHub = class {
   }
 };
 
-// ../server/src/actions.ts
-async function setFileViewed(gh, prId, path, viewed) {
-  const mutation = viewed ? "markFileAsViewed" : "unmarkFileAsViewed";
-  await gh.graphql(
-    `mutation($id: ID!, $path: String!) { ${mutation}(input: { pullRequestId: $id, path: $path }) { clientMutationId } }`,
-    { id: prId, path }
-  );
-}
-async function replyToThread(gh, threadId, body, pendingReviewId) {
-  const data = await gh.graphql(
-    `mutation($thread: ID!, $body: String!, $review: ID) {
-      addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $thread, body: $body, pullRequestReviewId: $review }) {
-        comment { id }
-      }
-    }`,
-    { thread: threadId, body, review: pendingReviewId }
-  );
-  return data.addPullRequestReviewThreadReply.comment.id;
-}
-async function setThreadResolved(gh, threadId, resolved) {
-  const mutation = resolved ? "resolveReviewThread" : "unresolveReviewThread";
-  await gh.graphql(`mutation($id: ID!) { ${mutation}(input: { threadId: $id }) { thread { id } } }`, {
-    id: threadId
-  });
-}
-function threadInput(t2) {
-  if (t2.subjectType === "FILE") return { path: t2.path, body: t2.body, subjectType: "FILE" };
-  return {
-    path: t2.path,
-    body: t2.body,
-    subjectType: "LINE",
-    line: t2.line,
-    side: t2.side,
-    ...t2.startLine !== null && t2.startLine !== t2.line ? { startLine: t2.startLine, startSide: t2.startSide ?? t2.side } : {}
-  };
-}
-async function addThread(gh, prId, pendingReviewId, thread, mode) {
-  if (mode === "single" && pendingReviewId) {
-    throw new GitHubError(
-      "Une review est en attente : ajoutez le commentaire \xE0 la review ou soumettez-la d\u2019abord.",
-      409
-    );
-  }
-  let reviewId = pendingReviewId;
-  if (!reviewId) {
-    const created = await gh.graphql(
-      `mutation($id: ID!) { addPullRequestReview(input: { pullRequestId: $id }) { pullRequestReview { id } } }`,
-      { id: prId }
-    );
-    reviewId = created.addPullRequestReview.pullRequestReview.id;
-  }
-  try {
-    await gh.graphql(
-      `mutation($input: AddPullRequestReviewThreadInput!) { addPullRequestReviewThread(input: $input) { thread { id } } }`,
-      { input: { pullRequestReviewId: reviewId, ...threadInput(thread) } }
-    );
-  } catch (error62) {
-    if (!pendingReviewId) await discardReview(gh, reviewId).catch(() => void 0);
-    throw error62;
-  }
-  if (mode === "single") await submitReview(gh, prId, reviewId, "COMMENT", "");
-}
-async function submitReview(gh, prId, pendingReviewId, event, body) {
-  if (pendingReviewId) {
-    await gh.graphql(
-      `mutation($id: ID!, $event: PullRequestReviewEvent!, $body: String) {
-        submitPullRequestReview(input: { pullRequestReviewId: $id, event: $event, body: $body }) { pullRequestReview { id } }
-      }`,
-      { id: pendingReviewId, event, body: body || null }
-    );
-    return;
-  }
-  await gh.graphql(
-    `mutation($input: AddPullRequestReviewInput!) { addPullRequestReview(input: $input) { pullRequestReview { id } } }`,
-    { input: { pullRequestId: prId, event, ...body ? { body } : {} } }
-  );
-}
-async function discardReview(gh, reviewId) {
-  await gh.graphql(
-    `mutation($id: ID!) { deletePullRequestReview(input: { pullRequestReviewId: $id }) { pullRequestReview { id } } }`,
-    { id: reviewId }
-  );
-}
-async function addIssueComment(gh, subjectId, body) {
-  await gh.graphql(
-    `mutation($id: ID!, $body: String!) { addComment(input: { subjectId: $id, body: $body }) { clientMutationId } }`,
-    {
-      id: subjectId,
-      body
-    }
-  );
-}
-async function deleteReviewComment(gh, commentId) {
-  await gh.graphql(
-    `mutation($id: ID!) { deletePullRequestReviewComment(input: { id: $id }) { clientMutationId } }`,
-    { id: commentId }
-  );
-}
-async function updateReviewComment(gh, commentId, body) {
-  await gh.graphql(
-    `mutation($id: ID!, $body: String!) {
-      updatePullRequestReviewComment(input: { pullRequestReviewCommentId: $id, body: $body }) { clientMutationId }
-    }`,
-    { id: commentId, body }
-  );
-}
-async function applySuggestion(gh, ref, input2) {
-  const branch = await gh.rest(
-    `/repos/${ref.owner}/${ref.repo}/branches/${encodeURIComponent(input2.branch)}`
-  );
-  if (branch.commit.sha !== input2.expectedHeadOid) {
-    throw new GitHubError(
-      "La branche a boug\xE9 depuis le chargement de la PR : rechargez avant d\u2019appliquer.",
-      409
-    );
-  }
-  const encodedPath = input2.path.split("/").map(encodeURIComponent).join("/");
-  const file2 = await gh.rest(
-    `/repos/${ref.owner}/${ref.repo}/contents/${encodedPath}?ref=${input2.expectedHeadOid}`
-  );
-  const text = Buffer.from(file2.content, "base64").toString("utf8");
-  const eol = text.includes("\r\n") ? "\r\n" : "\n";
-  const lines = text.split(eol);
-  if (input2.endLine > lines.length || input2.startLine < 1 || input2.startLine > input2.endLine) {
-    throw new GitHubError("Lignes de la suggestion hors du fichier.", 422);
-  }
-  const replacement = input2.replacement.replace(/\r?\n$/, "").split(/\r?\n/);
-  lines.splice(
-    input2.startLine - 1,
-    input2.endLine - input2.startLine + 1,
-    ...input2.replacement === "" ? [] : replacement
-  );
-  const res = await gh.rest(
-    `/repos/${ref.owner}/${ref.repo}/contents/${encodedPath}`,
-    {
-      method: "PUT",
-      body: {
-        message: input2.message,
-        content: Buffer.from(lines.join(eol), "utf8").toString("base64"),
-        sha: file2.sha,
-        branch: input2.branch
-      }
-    }
-  );
-  return res.commit.sha;
-}
-
 // ../server/src/github/queries.ts
 var PR_SUMMARY = (
   /* GraphQL */
@@ -26069,6 +25929,34 @@ var INBOX_FINGERPRINT_QUERY = (
   }
 `
 );
+var REVIEW_COMMENT_FIELDS = (
+  /* GraphQL */
+  `
+  fragment ReviewCommentFields on PullRequestReviewComment {
+    id
+    databaseId
+    url
+    body
+    bodyHTML
+    createdAt
+    state
+    diffHunk
+    author {
+      login
+      avatarUrl
+    }
+    originalCommit {
+      oid
+    }
+    pullRequestReview {
+      id
+      state
+    }
+    viewerCanUpdate
+    viewerCanDelete
+  }
+`
+);
 var THREAD_FIELDS = (
   /* GraphQL */
   `
@@ -26092,30 +25980,11 @@ var THREAD_FIELDS = (
     viewerCanReply
     comments(first: 100) {
       nodes {
-        id
-        databaseId
-        url
-        body
-        bodyHTML
-        createdAt
-        state
-        diffHunk
-        author {
-          login
-          avatarUrl
-        }
-        originalCommit {
-          oid
-        }
-        pullRequestReview {
-          id
-          state
-        }
-        viewerCanUpdate
-        viewerCanDelete
+        ...ReviewCommentFields
       }
     }
   }
+  ${REVIEW_COMMENT_FIELDS}
 `
 );
 var PR_QUERY = (
@@ -26380,6 +26249,28 @@ var PR_FINGERPRINT_QUERY = (
 `
 );
 
+// ../server/src/github/blobs.ts
+var BATCH = 50;
+async function fetchTexts(gh, ref, expressions) {
+  const texts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < expressions.length; i += BATCH) {
+    const batch = expressions.slice(i, i + BATCH);
+    const vars = { owner: ref.owner, repo: ref.repo };
+    batch.forEach((e, k) => vars[`e${k}`] = e);
+    const query = `query(${["$owner: String!", "$repo: String!", ...batch.map((_, k) => `$e${k}: String!`)].join(", ")}) {
+      repository(owner: $owner, name: $repo) {
+        ${batch.map((_, k) => `f${k}: object(expression: $e${k}) { ... on Blob { text isBinary isTruncated } }`).join("\n")}
+      }
+    }`;
+    const data = await gh.graphql(query, vars);
+    batch.forEach((e, k) => {
+      const blob = data.repository[`f${k}`];
+      texts.set(e, blob && !blob.isBinary && !blob.isTruncated ? blob.text : null);
+    });
+  }
+  return texts;
+}
+
 // ../server/src/inbox.ts
 var SCOPE_CHUNK = 20;
 function scopeChunks(config2) {
@@ -26695,8 +26586,8 @@ async function loadPr(gh, store, ref) {
     seenHunks: store.seenHunks(key)
   };
 }
-function toThread(t2, me, lastReadId) {
-  const comments = t2.comments.nodes.map((c) => ({
+function toComment(c) {
+  return {
     id: c.id,
     databaseId: c.databaseId,
     url: c.url,
@@ -26708,7 +26599,10 @@ function toThread(t2, me, lastReadId) {
     originalCommitOid: c.originalCommit?.oid ?? null,
     canUpdate: c.viewerCanUpdate,
     canDelete: c.viewerCanDelete
-  }));
+  };
+}
+function toThread(t2, me, lastReadId) {
+  const comments = t2.comments.nodes.map(toComment);
   const readIdx = lastReadId ? comments.findIndex((c) => c.id === lastReadId) : -1;
   const unread = comments.slice(readIdx + 1).filter((c) => c.author?.login !== me).length;
   return {
@@ -26748,6 +26642,7 @@ function restFilesToDiff(files) {
     if (f.status === "added") header.push("new file mode 100644");
     if (f.status === "removed") header.push("deleted file mode 100644");
     if (f.status === "renamed") header.push(`rename from ${oldPath}`, `rename to ${f.filename}`);
+    if (f.sha && f.status !== "removed") header.push(`index 0000000..${f.sha}`);
     if (f.patch !== void 0) {
       header.push(
         f.status === "added" ? "--- /dev/null" : `--- a/${oldPath}`,
@@ -26797,6 +26692,186 @@ async function loadDiff(gh, store, ref, base, head, isFullPr) {
   const files = compare.files ?? [];
   return { base, head, files: restFilesToDiff(files), missingFiles: files.length >= 300 ? 1 : 0 };
 }
+async function loadBlobs(gh, store, ref, oids) {
+  const key = (oid) => `blob:${ref.owner}/${ref.repo}:${oid}`.toLowerCase();
+  const out = {};
+  const missing = [];
+  for (const oid of oids) {
+    const cached2 = store.getDiff(key(oid));
+    if (cached2 === void 0) missing.push(oid);
+    else out[oid] = JSON.parse(cached2);
+  }
+  if (missing.length > 0) {
+    const texts = await fetchTexts(gh, ref, missing);
+    for (const oid of missing) {
+      const text = texts.get(oid) ?? null;
+      store.putDiff(key(oid), JSON.stringify(text));
+      out[oid] = text;
+    }
+  }
+  return out;
+}
+
+// ../server/src/actions.ts
+async function setFileViewed(gh, prId, path, viewed) {
+  const mutation = viewed ? "markFileAsViewed" : "unmarkFileAsViewed";
+  await gh.graphql(
+    `mutation($id: ID!, $path: String!) { ${mutation}(input: { pullRequestId: $id, path: $path }) { clientMutationId } }`,
+    { id: prId, path }
+  );
+}
+async function replyToThread(gh, threadId, body, pendingReviewId) {
+  const data = await gh.graphql(
+    `mutation($thread: ID!, $body: String!, $review: ID) {
+      addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $thread, body: $body, pullRequestReviewId: $review }) {
+        comment { ...ReviewCommentFields }
+      }
+    }
+    ${REVIEW_COMMENT_FIELDS}`,
+    { thread: threadId, body, review: pendingReviewId }
+  );
+  return toComment(data.addPullRequestReviewThreadReply.comment);
+}
+async function setThreadResolved(gh, threadId, resolved) {
+  const mutation = resolved ? "resolveReviewThread" : "unresolveReviewThread";
+  await gh.graphql(`mutation($id: ID!) { ${mutation}(input: { threadId: $id }) { thread { id } } }`, {
+    id: threadId
+  });
+}
+function threadInput(t2) {
+  if (t2.subjectType === "FILE") return { path: t2.path, body: t2.body, subjectType: "FILE" };
+  return {
+    path: t2.path,
+    body: t2.body,
+    subjectType: "LINE",
+    line: t2.line,
+    side: t2.side,
+    ...t2.startLine !== null && t2.startLine !== t2.line ? { startLine: t2.startLine, startSide: t2.startSide ?? t2.side } : {}
+  };
+}
+async function addThread(gh, prId, pendingReviewId, thread, mode) {
+  if (mode === "single" && pendingReviewId) {
+    throw new GitHubError(
+      "Une review est en attente : ajoutez le commentaire \xE0 la review ou soumettez-la d\u2019abord.",
+      409
+    );
+  }
+  let reviewId = pendingReviewId;
+  if (!reviewId) {
+    const created2 = await gh.graphql(
+      `mutation($id: ID!) { addPullRequestReview(input: { pullRequestId: $id }) { pullRequestReview { id } } }`,
+      { id: prId }
+    );
+    reviewId = created2.addPullRequestReview.pullRequestReview.id;
+  }
+  let node2;
+  try {
+    const data = await gh.graphql(
+      `mutation($input: AddPullRequestReviewThreadInput!) {
+        addPullRequestReviewThread(input: $input) { thread { ...ThreadFields } }
+      }
+      ${THREAD_FIELDS}`,
+      { input: { pullRequestReviewId: reviewId, ...threadInput(thread) } }
+    );
+    node2 = data.addPullRequestReviewThread.thread;
+  } catch (error62) {
+    if (!pendingReviewId) await discardReview(gh, reviewId).catch(() => void 0);
+    throw error62;
+  }
+  const created = toThread(node2, "", node2.comments.nodes.at(-1)?.id);
+  if (mode === "review") return { thread: created, pendingReviewId: reviewId };
+  await submitReview(gh, prId, reviewId, "COMMENT", "");
+  return {
+    thread: { ...created, pending: false, comments: created.comments.map((c) => ({ ...c, pending: false })) },
+    pendingReviewId: null
+  };
+}
+async function submitReview(gh, prId, pendingReviewId, event, body) {
+  if (pendingReviewId) {
+    await gh.graphql(
+      `mutation($id: ID!, $event: PullRequestReviewEvent!, $body: String) {
+        submitPullRequestReview(input: { pullRequestReviewId: $id, event: $event, body: $body }) { pullRequestReview { id } }
+      }`,
+      { id: pendingReviewId, event, body: body || null }
+    );
+    return;
+  }
+  await gh.graphql(
+    `mutation($input: AddPullRequestReviewInput!) { addPullRequestReview(input: $input) { pullRequestReview { id } } }`,
+    { input: { pullRequestId: prId, event, ...body ? { body } : {} } }
+  );
+}
+async function discardReview(gh, reviewId) {
+  await gh.graphql(
+    `mutation($id: ID!) { deletePullRequestReview(input: { pullRequestReviewId: $id }) { pullRequestReview { id } } }`,
+    { id: reviewId }
+  );
+}
+async function addIssueComment(gh, subjectId, body) {
+  const data = await gh.graphql(
+    `mutation($id: ID!, $body: String!) {
+      addComment(input: { subjectId: $id, body: $body }) {
+        commentEdge { node { id url body bodyHTML createdAt author { login avatarUrl } } }
+      }
+    }`,
+    { id: subjectId, body }
+  );
+  return { kind: "comment", ...data.addComment.commentEdge.node, unread: false };
+}
+async function deleteReviewComment(gh, commentId) {
+  await gh.graphql(
+    `mutation($id: ID!) { deletePullRequestReviewComment(input: { id: $id }) { clientMutationId } }`,
+    { id: commentId }
+  );
+}
+async function updateReviewComment(gh, commentId, body) {
+  await gh.graphql(
+    `mutation($id: ID!, $body: String!) {
+      updatePullRequestReviewComment(input: { pullRequestReviewCommentId: $id, body: $body }) { clientMutationId }
+    }`,
+    { id: commentId, body }
+  );
+}
+async function applySuggestion(gh, ref, input2) {
+  const branch = await gh.rest(
+    `/repos/${ref.owner}/${ref.repo}/branches/${encodeURIComponent(input2.branch)}`
+  );
+  if (branch.commit.sha !== input2.expectedHeadOid) {
+    throw new GitHubError(
+      "La branche a boug\xE9 depuis le chargement de la PR : rechargez avant d\u2019appliquer.",
+      409
+    );
+  }
+  const encodedPath = input2.path.split("/").map(encodeURIComponent).join("/");
+  const file2 = await gh.rest(
+    `/repos/${ref.owner}/${ref.repo}/contents/${encodedPath}?ref=${input2.expectedHeadOid}`
+  );
+  const text = Buffer.from(file2.content, "base64").toString("utf8");
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const lines = text.split(eol);
+  if (input2.endLine > lines.length || input2.startLine < 1 || input2.startLine > input2.endLine) {
+    throw new GitHubError("Lignes de la suggestion hors du fichier.", 422);
+  }
+  const replacement = input2.replacement.replace(/\r?\n$/, "").split(/\r?\n/);
+  lines.splice(
+    input2.startLine - 1,
+    input2.endLine - input2.startLine + 1,
+    ...input2.replacement === "" ? [] : replacement
+  );
+  const res = await gh.rest(
+    `/repos/${ref.owner}/${ref.repo}/contents/${encodedPath}`,
+    {
+      method: "PUT",
+      body: {
+        message: input2.message,
+        content: Buffer.from(lines.join(eol), "utf8").toString("base64"),
+        sha: file2.sha,
+        branch: input2.branch
+      }
+    }
+  );
+  return res.commit.sha;
+}
 
 // ../server/src/links/extract.ts
 import ts from "typescript";
@@ -28195,7 +28270,6 @@ function resolveGradleProject(projectPath, from, gradleRoots) {
 
 // ../server/src/prLinks.ts
 var LINKS_VERSION = 6;
-var BATCH = 50;
 var languageSchema = external_exports.enum([
   "typescript",
   "javascript",
@@ -28306,13 +28380,14 @@ async function loadWorkspace(gh, store, ref, head) {
   const texts = await fetchTexts(
     gh,
     ref,
-    manifests.map((path) => ({ path, oid: head }))
+    manifests.map((path) => `${head}:${path}`)
   );
-  const packages = parseWorkspace(manifests.map((path) => ({ path, text: texts.get(path) ?? null })));
+  const textOf = (path) => texts.get(`${head}:${path}`) ?? null;
+  const packages = parseWorkspace(manifests.map((path) => ({ path, text: textOf(path) })));
   const refs = packages.map((p) => ({
     name: p.name,
     root: p.root,
-    entries: entryCandidates(p, texts.get(p.manifest) ?? null)
+    entries: entryCandidates(p, textOf(p.manifest))
   }));
   return { packages, refs };
 }
@@ -28363,25 +28438,6 @@ ${to}`;
     packageEdges
   };
 }
-async function fetchTexts(gh, ref, wanted) {
-  const texts = /* @__PURE__ */ new Map();
-  for (let i = 0; i < wanted.length; i += BATCH) {
-    const batch = wanted.slice(i, i + BATCH);
-    const vars = { owner: ref.owner, repo: ref.repo };
-    batch.forEach((w, k) => vars[`e${k}`] = `${w.oid}:${w.path}`);
-    const query = `query(${["$owner: String!", "$repo: String!", ...batch.map((_, k) => `$e${k}: String!`)].join(", ")}) {
-      repository(owner: $owner, name: $repo) {
-        ${batch.map((_, k) => `f${k}: object(expression: $e${k}) { ... on Blob { text isBinary isTruncated } }`).join("\n")}
-      }
-    }`;
-    const data = await gh.graphql(query, vars);
-    batch.forEach((w, k) => {
-      const blob = data.repository[`f${k}`];
-      texts.set(w.path, blob && !blob.isBinary && !blob.isTruncated ? blob.text : null);
-    });
-  }
-  return texts;
-}
 async function loadLinks(gh, store, ref, base, head, fullPr) {
   const cacheKey2 = `links:v${LINKS_VERSION}:${ref.owner}/${ref.repo}:${base}...${head}`.toLowerCase();
   const cached2 = store.getDiff(cacheKey2);
@@ -28391,16 +28447,11 @@ async function loadLinks(gh, store, ref, base, head, fullPr) {
   }
   const diff = await loadDiff(gh, store, ref, base, head, fullPr);
   const readable = diff.files.filter((f) => !f.binary);
-  const texts = await fetchTexts(
-    gh,
-    ref,
-    readable.map(
-      (f) => f.status === "deleted" ? { path: f.oldPath, oid: base } : { path: f.path, oid: head }
-    )
-  );
+  const expression = (f) => f.status === "deleted" ? `${base}:${f.oldPath}` : `${head}:${f.path}`;
+  const texts = await fetchTexts(gh, ref, readable.map(expression));
   const sources = diff.files.map((f) => ({
     path: f.path,
-    text: f.binary ? null : texts.get(f.status === "deleted" ? f.oldPath : f.path) ?? null
+    text: f.binary ? null : texts.get(expression(f)) ?? null
   }));
   const workspace = await loadWorkspace(gh, store, ref, head);
   const graph = buildLinkGraph(sources, workspace ? { packages: workspace.refs } : void 0);
@@ -28836,6 +28887,7 @@ var prRouter = router({
   get: procedure.input(prRefSchema).query(({ ctx, input: input2 }) => loadPr(ctx.gh, ctx.store, input2)),
   diff: procedure.input(external_exports.object({ ref: prRefSchema, base: shaSchema, head: shaSchema, fullPr: external_exports.boolean() })).query(({ ctx, input: input2 }) => loadDiff(ctx.gh, ctx.store, input2.ref, input2.base, input2.head, input2.fullPr)),
   links: procedure.input(external_exports.object({ ref: prRefSchema, base: shaSchema, head: shaSchema, fullPr: external_exports.boolean() })).query(({ ctx, input: input2 }) => loadLinks(ctx.gh, ctx.store, input2.ref, input2.base, input2.head, input2.fullPr)),
+  blobs: procedure.input(external_exports.object({ ref: prRefSchema, oids: external_exports.array(shaSchema).min(1).max(2) })).query(({ ctx, input: input2 }) => loadBlobs(ctx.gh, ctx.store, input2.ref, input2.oids)),
   onChange: procedure.input(prRefSchema).subscription(async function* ({ ctx, input: input2, signal }) {
     yield* pollChanges(PR_POLL_MS, signal, () => prFingerprint(ctx.gh, input2, signal));
   }),