Add files using upload-large-folder tool

mods/diff/hooks/entry-kinds-of/entry-kinds-of.ts

@@ -0,0 +1,17 @@
+import type Git from '../git'
+import type { Host } from '../host'
+
+/**
+ * A directory's entries by name with their own kinds, through the host's
+ * listing (no link followed); null when it cannot be listed.
+ *
+ * @param engine the bound host
+ * @returns the probe (GitDeps `entryKindsOf`)
+ */
+export const entryKindsOf =
+  (engine: Host) =>
+  (dir: string): Promise<ReadonlyMap<string, Git.EntryKind> | null> =>
+    engine.listDir(dir).then(
+      entries => new Map(entries.map(entry => [entry.name, entry.kind])),
+      () => null,
+    )

mods/diff/hooks/git/argv/diff-leading-args.ts

@@ -0,0 +1,20 @@
+/**
+ * The leading argv of every `git diff` the plugin runs: the config the
+ * engine's own diff panel pins, `core.quotePath=false`, and raw-blob flags.
+ *
+ * Root-relative paths whatever `diff.relative` says, non-ASCII paths as
+ * their own bytes, no optional locks, no child `git status` in a dirty
+ * submodule, and no external diff or textconv driver even on a stats pass.
+ */
+export const DIFF_LEADING_ARGS = [
+  '--no-optional-locks',
+  '-c',
+  'diff.relative=false',
+  '-c',
+  'core.quotePath=false',
+  'diff',
+  '--no-ext-diff',
+  '--no-textconv',
+  '--ignore-submodules=dirty',
+  '--submodule=short',
+] as const

mods/diff/hooks/git/argv/git-child-env/git-child-env.ts

@@ -0,0 +1,8 @@
+/**
+ * The environment laid over every git child the plugin spawns: the C
+ * locale, so `--shortstat` and git's messages parse the same everywhere.
+ *
+ * Nothing else is pinned, as for the built-in panel's own diff children:
+ * a partial clone lazy-fetches as it would for `git diff` at the prompt.
+ */
+export const GIT_CHILD_ENV = { LC_ALL: 'C', LANGUAGE: '' } as const

mods/diff/hooks/git/argv/git-child-env/index.ts

@@ -0,0 +1,3 @@
+export * from './git-child-env.js'
+
+export * as default from '.'

mods/diff/hooks/git/argv/index.ts

@@ -0,0 +1,6 @@
+export * from './diff-leading-args.js'
+export * from './git-child-env'
+export * from './no-optional-locks.js'
+export * from './pinned-lead-of'
+
+export * as default from '.'

mods/diff/hooks/git/argv/no-optional-locks.ts

@@ -0,0 +1,5 @@
+/**
+ * The flag every probe carries so a read never takes the index lock from a
+ * git the person is running.
+ */
+export const NO_OPTIONAL_LOCKS = '--no-optional-locks'

mods/diff/hooks/git/argv/pinned-lead-of/index.ts

@@ -0,0 +1,3 @@
+export * from './pinned-lead-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/argv/pinned-lead-of/pinned-lead-of.ts

@@ -0,0 +1,18 @@
+import type Types from '../../types'
+
+/**
+ * The argv that leads every git child once the repository is pinned: its
+ * git directory and working tree named, as the built-in panel pins them.
+ *
+ * With `--git-dir` given git discovers nothing from its cwd, so a nested
+ * repository the shell later moves into is never the one read.
+ *
+ * @param repository the session's pinned repository
+ * @returns the leading argv
+ */
+export const pinnedLeadOf = (
+  repository: Types.Repository,
+): readonly string[] => [
+  `--git-dir=${repository.gitDir}`,
+  `--work-tree=${repository.toplevel}`,
+]

mods/diff/hooks/git/cut-hunks/cut-hunks.ts

@@ -0,0 +1,30 @@
+import Limits from '../../limits'
+import type Types from '../types'
+
+/**
+ * Hunks with their lines cut at MAX_LINES_PER_FILE in all, in order, and
+ * whether any line was dropped.
+ *
+ * The one bound on every body the pane draws or attaches, whether git
+ * printed it or the transcript carried it.
+ *
+ * @param hunks the hunks as parsed or reported
+ * @returns the cut hunks and whether the cut dropped lines
+ */
+export function cutHunks(
+  hunks: readonly Types.Hunk[],
+): Pick<Types.FileHunks, 'hunks' | 'isTruncated'> {
+  let budget = Limits.MAX_LINES_PER_FILE
+  let total = 0
+
+  return {
+    hunks: hunks.map(hunk => {
+      const lines = hunk.lines.slice(0, budget)
+      budget -= lines.length
+      total += hunk.lines.length
+
+      return { ...hunk, lines }
+    }),
+    isTruncated: total > Limits.MAX_LINES_PER_FILE,
+  }
+}

mods/diff/hooks/git/cut-hunks/index.ts

@@ -0,0 +1,3 @@
+export * from './cut-hunks.js'
+
+export * as default from '.'

mods/diff/hooks/git/display-path-of/display-path-of.ts

@@ -0,0 +1,17 @@
+import { renameDisplayOf } from '../rename-display-of'
+import type Types from '../types'
+
+/**
+ * A row's name as the built-in lists it: the path, or for a rename the one
+ * line `git diff --stat` prints for it (renameDisplayOf).
+ *
+ * @param file the row
+ * @returns the name to draw and to sort by
+ */
+export function displayPathOf(
+  file: Pick<Types.FileStat, 'path' | 'renamedFrom'>,
+): string {
+  const { renamedFrom, path } = file
+
+  return renamedFrom === null ? path : renameDisplayOf(renamedFrom, path)
+}

mods/diff/hooks/git/display-path-of/index.ts

@@ -0,0 +1,3 @@
+export * from './display-path-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/empty-file-hunks/empty-file-hunks.ts

@@ -0,0 +1,11 @@
+import type Types from '../types'
+
+/**
+ * A body with nothing to draw: an untracked or binary row's, or a staged
+ * file's whose index body went stale on an unborn HEAD.
+ */
+export const EMPTY_FILE_HUNKS: Types.FileHunks = Object.freeze({
+  hunks: [],
+  isTruncated: false,
+  isLarge: false,
+})

mods/diff/hooks/git/empty-file-hunks/index.ts

@@ -0,0 +1,3 @@
+export * from './empty-file-hunks.js'
+
+export * as default from '.'

mods/diff/hooks/git/failed-run/failed-run.ts

@@ -0,0 +1,11 @@
+import type Types from '../types'
+
+/**
+ * What a child that never ran, was killed, or timed out reads as: exit code
+ * -1 and no output, so a runner never rejects (GitRun).
+ */
+export const FAILED_RUN: Types.RunResult = Object.freeze({
+  exitCode: -1,
+  stdout: '',
+  stderr: '',
+})

mods/diff/hooks/git/failed-run/index.ts

@@ -0,0 +1,3 @@
+export * from './failed-run.js'
+
+export * as default from '.'

mods/diff/hooks/git/fetch-diff/fetch-diff.ts

@@ -0,0 +1,33 @@
+import Probes from '../probes'
+import Tiers from '../tiers'
+import type Types from '../types'
+
+/**
+ * One fetch of the session's pinned repository, as the built-in panel
+ * fetches; every git child names it so paths stay root-relative.
+ *
+ * Mid-merge, mid-rebase, mid-cherry-pick or mid-revert, or when git cannot
+ * answer, it is unavailable and the caller keeps what it had.
+ *
+ * @param deps the host: pinned git, the repository, the file probes
+ * @param mode what to compare against
+ * @returns the outcome
+ */
+export async function fetchDiff(
+  deps: Types.GitDeps,
+  mode: Types.BaseMode,
+): Promise<Types.FetchOutcome> {
+  const isBusy = await Probes.isTransient(
+    deps.entryKindsOf,
+    deps.repository.gitDir,
+  )
+
+  if (isBusy) {
+    return { kind: 'unavailable' }
+  }
+
+  const context = Tiers.fetchContextOf(deps, mode)
+  const isBranch = mode === 'branch'
+
+  return isBranch ? Tiers.branchTier(context) : Tiers.workingTreeTier(context)
+}

mods/diff/hooks/git/fetch-diff/index.ts

@@ -0,0 +1,3 @@
+export * from './fetch-diff.js'
+
+export * as default from '.'

mods/diff/hooks/git/fetch-file-hunks/fetch-file-hunks.ts

@@ -0,0 +1,51 @@
+import Argv from '../argv'
+import { EMPTY_FILE_HUNKS } from '../empty-file-hunks'
+import Parse from '../parse'
+import type Types from '../types'
+import { isLastOfDiff } from './is-last-of-diff'
+import { withClosingLine } from './with-closing-line'
+
+/**
+ * One file's hunks against the base its row was read against, so body and
+ * counts agree, by literal pathspec, as the built-in panel reads hunks.
+ *
+ * An untracked, binary or renamed row (the built-in shows a rename's
+ * counts, never its body), or on an unborn HEAD a file edited after
+ * staging, answers no hunks; each file but the last, a closing empty row.
+ *
+ * @param run runs git against the pinned repository
+ * @param data the fetch the row belongs to
+ * @param file the row
+ * @returns the parsed body, or null when git failed
+ */
+export async function fetchFileHunks(
+  run: Types.GitRun,
+  data: Types.DiffData,
+  file: Types.FileStat,
+): Promise<Types.FileHunks | null> {
+  const hasNoBody =
+    file.isUntracked ||
+    file.isBinary ||
+    file.renamedFrom !== null ||
+    data.stalePaths.includes(file.path)
+
+  if (hasNoBody) {
+    return EMPTY_FILE_HUNKS
+  }
+
+  const { exitCode, stdout } = await run([
+    '--literal-pathspecs',
+    ...Argv.DIFF_LEADING_ARGS,
+    data.baseRef,
+    '--',
+    file.path,
+  ])
+
+  if (exitCode !== 0) {
+    return null
+  }
+
+  const body = Parse.parseFileDiff(stdout)
+
+  return isLastOfDiff(data, file) ? body : withClosingLine(body)
+}

mods/diff/hooks/git/fetch-file-hunks/index.ts

@@ -0,0 +1,5 @@
+export * from './fetch-file-hunks.js'
+export * from './is-last-of-diff'
+export * from './with-closing-line'
+
+export * as default from '.'

mods/diff/hooks/git/fetch-file-hunks/is-last-of-diff/index.ts

@@ -0,0 +1,3 @@
+export * from './is-last-of-diff.js'
+
+export * as default from '.'

mods/diff/hooks/git/fetch-file-hunks/is-last-of-diff/is-last-of-diff.ts

@@ -0,0 +1,18 @@
+import type Types from '../../types'
+
+/**
+ * Whether a row is the last file of the whole diff git printed for its
+ * fetch: the last tracked row, the untracked ones being listed apart.
+ *
+ * The built-in reads that diff in one piece and trims its end, so the last
+ * file alone has no closing empty line to draw (withClosingLine).
+ *
+ * @param data the fetch the row belongs to
+ * @param file the row
+ * @returns whether git printed this file last
+ */
+export const isLastOfDiff = (
+  data: Types.DiffData,
+  file: Types.FileStat,
+): boolean =>
+  data.files.filter(row => !row.isUntracked).at(-1)?.path === file.path

mods/diff/hooks/git/fetch-file-hunks/with-closing-line/index.ts

@@ -0,0 +1,3 @@
+export * from './with-closing-line.js'
+
+export * as default from '.'

mods/diff/hooks/git/fetch-file-hunks/with-closing-line/with-closing-line.ts

@@ -0,0 +1,27 @@
+import type Types from '../../types'
+
+/**
+ * A parsed body with one empty context row after its last hunk's lines, as
+ * the built-in panel draws the empty line that closes git's output.
+ *
+ * The built-in reads every file's diff in one piece: the newline before the
+ * next file's header parses as a context line of the file before it. A
+ * body with no hunk, or one already cut, gains nothing.
+ *
+ * @param body the parsed body
+ * @returns the body, its last hunk one row longer
+ */
+export function withClosingLine(body: Types.FileHunks): Types.FileHunks {
+  const last = body.hunks.at(-1)
+  const isClosed = last !== undefined && !body.isTruncated
+
+  return isClosed
+    ? {
+        ...body,
+        hunks: [
+          ...body.hunks.slice(0, -1),
+          { ...last, lines: [...last.lines, ' '] },
+        ],
+      }
+    : body
+}

mods/diff/hooks/git/git-backend-of.ts

@@ -0,0 +1,79 @@
+import type Backend from '../backend'
+import Limits from '../limits'
+import Argv from './argv'
+import { FAILED_RUN } from './failed-run'
+import { fetchDiff } from './fetch-diff'
+import { fetchFileHunks } from './fetch-file-hunks'
+import { GIT_BASE_MODES } from './git-base-modes'
+import { GIT_WORDS } from './git-words'
+import Probes from './probes'
+import type Types from './types'
+
+/**
+ * The git backend over the session's directory: the repository read with
+ * one `rev-parse` in that directory, then every child pinned to it.
+ *
+ * Each child runs with `--git-dir`, `--work-tree` and cwd the top, under
+ * the C locale and the fetch's timeout (the built-in's execPinnedGit); the
+ * first fetch reads the paths dirty then, once (Probes.dirtyPathsOf).
+ *
+ * @param host the bound host's runner and probes
+ * @returns the backend, or null outside a git working tree
+ */
+export async function gitBackendOf(
+  host: Backend.BackendHost,
+): Promise<Backend.Backend | null> {
+  const runOf =
+    (pinned: Types.Repository | null): Types.GitRun =>
+    async argv => {
+      try {
+        return await host.run(
+          ['git', ...(pinned ? Argv.pinnedLeadOf(pinned) : []), ...argv],
+          {
+            timeoutMs: Limits.GIT_TIMEOUT_MS,
+            env: Argv.GIT_CHILD_ENV,
+            ...(pinned && { cwd: pinned.toplevel }),
+          },
+        )
+      } catch {
+        return FAILED_RUN
+      }
+    }
+
+  const repository = await Probes.repositoryOf(runOf(null))
+
+  if (!repository) {
+    return null
+  }
+
+  const run = runOf(repository)
+
+  let baseline: Promise<ReadonlySet<string> | null> | null = null
+
+  const depsOf = (dirty: ReadonlySet<string> | null): Types.GitDeps => ({
+    run,
+    repository,
+    mtimeOf: host.mtimeOf,
+    entryKindsOf: host.entryKindsOf,
+    sessionStartMs: host.sessionStartMsOf(),
+    baseline: dirty,
+    onBranchBase: host.onBranchBase,
+  })
+
+  return {
+    repository,
+    baseModes: GIT_BASE_MODES,
+    words: GIT_WORDS,
+    fetchDiff: async mode => {
+      baseline ??= Probes.dirtyPathsOf(run)
+
+      return fetchDiff(depsOf(await baseline), mode)
+    },
+    fetchFileHunks: (data, file) => fetchFileHunks(run, data, file),
+    headKeyOf: () =>
+      Probes.headKeyOf(
+        { ...depsOf(null), readFile: host.readFile },
+        repository,
+      ),
+  }
+}

mods/diff/hooks/git/git-base-modes/git-base-modes.ts

@@ -0,0 +1,10 @@
+import type Types from '../types'
+
+/**
+ * The comparisons git offers, in picker order: all three.
+ */
+export const GIT_BASE_MODES: readonly Types.BaseMode[] = Object.freeze([
+  'session',
+  'uncommitted',
+  'branch',
+])

mods/diff/hooks/git/git-base-modes/index.ts

@@ -0,0 +1,3 @@
+export * from './git-base-modes.js'
+
+export * as default from '.'

mods/diff/hooks/git/git-words/git-words.ts

@@ -0,0 +1,19 @@
+import type Backend from '../../backend'
+
+/**
+ * The pane's git words, unquoted as DiffDetailView words them.
+ *
+ * Compared with HEAD, read by `git diff`, untracked files listed by git and
+ * staged with `git add :/…`.
+ */
+export const GIT_WORDS: Backend.BackendWords = Object.freeze({
+  base: 'HEAD',
+  diffCommand: 'git diff',
+  lister: 'git',
+  untrackedNoteOf: (path: string, isPasteable: boolean) => [
+    'New file not yet staged.',
+    isPasteable
+      ? `Run \`git add :/${path}\` to see line counts.`
+      : 'Stage it with git add to see line counts.',
+  ],
+})

mods/diff/hooks/git/git-words/index.ts

@@ -0,0 +1,3 @@
+export * from './git-words.js'
+
+export * as default from '.'

mods/diff/hooks/git/hunk-after.ts

@@ -0,0 +1,20 @@
+import { countOf } from '../count-of'
+import type { Hunk } from './types'
+
+/**
+ * The hunk less its first so many lines, its starts moved past them so
+ * the numbers of the lines kept stay right; whole at 0.
+ *
+ * @param hunk the hunk, its lines body lines only
+ * @param count how many leading lines to drop
+ * @returns the rest of the hunk
+ */
+export function hunkAfter(hunk: Hunk, count: number): Hunk {
+  const dropped = hunk.lines.slice(0, count)
+
+  return {
+    oldStart: hunk.oldStart + countOf(dropped, line => !line.startsWith('+')),
+    newStart: hunk.newStart + countOf(dropped, line => !line.startsWith('-')),
+    lines: hunk.lines.slice(count),
+  }
+}

mods/diff/hooks/git/hunk-of/hunk-of.ts

@@ -0,0 +1,17 @@
+import type Types from '../types'
+
+/**
+ * One hunk from its header's captured starts and its body lines.
+ *
+ * @param starts the `old` and `new` groups of HUNK_HEADER, when it matched
+ * @param lines the body lines after the header
+ * @returns the hunk
+ */
+export const hunkOf = (
+  starts: Record<string, string> | undefined,
+  lines: readonly string[],
+): Types.Hunk => ({
+  oldStart: Number(starts?.old),
+  newStart: Number(starts?.new),
+  lines,
+})

mods/diff/hooks/git/hunk-of/index.ts

@@ -0,0 +1,3 @@
+export * from './hunk-of.js'
+
+export * as default from '.'

mods/diff/hooks/git/index.ts

@@ -0,0 +1,20 @@
+export * from './argv'
+export * from './cut-hunks'
+export * from './display-path-of'
+export * from './empty-file-hunks'
+export * from './failed-run'
+export * from './fetch-diff'
+export * from './fetch-file-hunks'
+export * from './git-backend-of.js'
+export * from './git-base-modes'
+export * from './git-words'
+export * from './hunk-after.js'
+export * from './hunk-of'
+export * from './large-file-hunks'
+export * from './parse'
+export * from './probes'
+export * from './rename-display-of'
+export * from './tiers'
+export * from './types'
+
+export * as default from '.'

mods/diff/hooks/git/large-file-hunks/index.ts

@@ -0,0 +1,3 @@
+export * from './large-file-hunks.js'
+
+export * as default from '.'

mods/diff/hooks/git/large-file-hunks/large-file-hunks.ts

@@ -0,0 +1,11 @@
+import type Types from '../types'
+
+/**
+ * The body of a file whose diff text passed MAX_DIFF_BYTES: no hunks, and
+ * the pane says the file is too large.
+ */
+export const LARGE_FILE_HUNKS: Types.FileHunks = Object.freeze({
+  hunks: [],
+  isTruncated: false,
+  isLarge: true,
+})

mods/diff/hooks/git/parse/hunk-header/hunk-header.ts

@@ -0,0 +1,5 @@
+/**
+ * A unified diff's hunk header, `@@ -old[,n] +new[,n] @@`, its two starts
+ * captured as `old` and `new`.
+ */
+export const HUNK_HEADER = /^@@ -(?<old>\d+)(?:,\d+)? \+(?<new>\d+)(?:,\d+)? @@/

mods/diff/hooks/git/parse/hunk-header/index.ts

@@ -0,0 +1,3 @@
+export * from './hunk-header.js'
+
+export * as default from '.'

mods/diff/hooks/git/parse/index.ts

@@ -0,0 +1,11 @@
+export * from './hunk-header'
+export * from './is-body-line'
+export * from './is-whole-answer'
+export * from './is-whole-listing'
+export * from './parse-file-diff.js'
+export * from './parse-numstat.js'
+export * from './parse-shortstat.js'
+export * from './rename-records'
+export * from './shortstat-pattern'
+
+export * as default from '.'

mods/diff/hooks/git/parse/is-body-line/index.ts

@@ -0,0 +1,3 @@
+export * from './is-body-line.js'
+
+export * as default from '.'

mods/diff/hooks/git/parse/is-body-line/is-body-line.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether a line after a hunk header is a body line (added, removed or
+ * context) rather than a note such as ``.
+ *
+ * @param line one line of `git diff` output
+ * @returns whether it starts with `+`, `-` or a space
+ */
+export const isBodyLine = (line: string) =>
+  line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')

mods/diff/hooks/git/parse/is-whole-answer/index.ts

@@ -0,0 +1,3 @@
+export * from './is-whole-answer.js'
+
+export * as default from '.'

mods/diff/hooks/git/parse/is-whole-answer/is-whole-answer.ts

@@ -0,0 +1,12 @@
+import type Types from '../../types'
+import { isWholeListing } from '../is-whole-listing'
+
+/**
+ * Whether a `-z` git child both succeeded and answered a whole listing,
+ * so its stdout may be parsed (isWholeListing).
+ *
+ * @param result what the child left
+ * @returns whether to parse it
+ */
+export const isWholeAnswer = (result: Types.RunResult) =>
+  result.exitCode === 0 && isWholeListing(result.stdout)

mods/diff/hooks/git/parse/is-whole-listing/index.ts

@@ -0,0 +1,5 @@
+export * from './is-under-utf8-ceiling'
+export * from './is-whole-listing.js'
+export * from './most-utf8-bytes'
+
+export * as default from '.'

mods/diff/hooks/git/parse/is-whole-listing/is-under-utf8-ceiling/index.ts

@@ -0,0 +1,3 @@
+export * from './is-under-utf8-ceiling.js'
+
+export * as default from '.'

mods/diff/hooks/git/parse/is-whole-listing/is-under-utf8-ceiling/is-under-utf8-ceiling.ts

@@ -0,0 +1,13 @@
+import { MOST_UTF8_BYTES } from '../most-utf8-bytes'
+
+/**
+ * Whether the text's UTF-8 encoding stays under a byte count, encoding it
+ * only when its length alone cannot already say so.
+ *
+ * @param text the text
+ * @param ceiling the byte count it must stay under
+ * @returns whether it is under
+ */
+export const isUnderUtf8Ceiling = (text: string, ceiling: number) =>
+  text.length * MOST_UTF8_BYTES < ceiling ||
+  new TextEncoder().encode(text).length < ceiling

mods/diff/hooks/git/parse/is-whole-listing/is-whole-listing.ts

@@ -0,0 +1,18 @@
+import Limits from '../../../limits'
+import { isUnderUtf8Ceiling } from './is-under-utf8-ceiling'
+import { MOST_UTF8_BYTES } from './most-utf8-bytes'
+
+/**
+ * Whether a listing arrived whole, so no record was cut or lost.
+ *
+ * Every record is terminated (NUL for `-z` listings, a newline for line
+ * records) and the text is short of the host's output cap by MOST_UTF8_BYTES,
+ * what a cut inside a multi-byte character can cost the decoded text.
+ *
+ * @param stdout the listing as `$.process.run` returned it
+ * @param terminator what ends every record; NUL when absent
+ * @returns whether it can be parsed as the whole answer
+ */
+export const isWholeListing = (stdout: string, terminator = '\0') =>
+  (stdout === '' || stdout.endsWith(terminator)) &&
+  isUnderUtf8Ceiling(stdout, Limits.HOST_OUTPUT_CAP_BYTES - MOST_UTF8_BYTES)

mods/diff/hooks/git/parse/is-whole-listing/most-utf8-bytes/index.ts

@@ -0,0 +1,3 @@
+export * from './most-utf8-bytes.js'
+
+export * as default from '.'

mods/diff/hooks/git/parse/is-whole-listing/most-utf8-bytes/most-utf8-bytes.ts

@@ -0,0 +1,5 @@
+/**
+ * The most bytes one UTF-16 code unit takes in UTF-8, and so both the
+ * bound on a text's encoded length and the most a cut character drops.
+ */
+export const MOST_UTF8_BYTES = 3

mods/diff/hooks/git/parse/parse-file-diff.ts

@@ -0,0 +1,41 @@
+import Limits from '../../limits'
+import { cutHunks } from '../cut-hunks'
+import { hunkOf } from '../hunk-of'
+import { LARGE_FILE_HUNKS } from '../large-file-hunks'
+import type Types from '../types'
+import { HUNK_HEADER } from './hunk-header'
+import { isBodyLine } from './is-body-line'
+
+/**
+ * One file's unified `git diff` output as hunks, the body cut at
+ * MAX_LINES_PER_FILE lines in all, as the built-in panel parses one file.
+ *
+ * Past MAX_DIFF_BYTES there are no hunks and `isLarge` is set; everything
+ * before the first hunk header is the file's header.
+ *
+ * @param stdout the command's standard output for that one path
+ * @returns the parsed body
+ */
+export function parseFileDiff(stdout: string): Types.FileHunks {
+  if (stdout.length > Limits.MAX_DIFF_BYTES) {
+    return LARGE_FILE_HUNKS
+  }
+
+  const rows = stdout.split('\n')
+
+  const headerRows = rows.flatMap((row, at) =>
+    HUNK_HEADER.test(row) ? [at] : [],
+  )
+
+  return {
+    ...cutHunks(
+      headerRows.map((at, ordinal) =>
+        hunkOf(
+          HUNK_HEADER.exec(rows[at] ?? '')?.groups,
+          rows.slice(at + 1, headerRows[ordinal + 1]).filter(isBodyLine),
+        ),
+      ),
+    ),
+    isLarge: false,
+  }
+}

mods/diff/hooks/git/parse/parse-numstat.ts

@@ -0,0 +1,66 @@
+import type Types from '../types'
+import { RENAME_RECORDS } from './rename-records'
+
+/**
+ * `git diff --numstat -z` output as totals over every row and the first
+ * rows up to the cap; a binary file (`-` counts) is a 0/0 row marked binary.
+ *
+ * A record is `<added>\t<removed>\t<path>` ended by NUL, the path raw; a
+ * rename is `<added>\t<removed>\t` then the old and the new path as the
+ * next two records, kept as one row under the new path.
+ *
+ * @param stdout the command's standard output
+ * @param maxFiles how many rows to keep
+ * @returns the totals and the kept rows
+ */
+export function parseNumstat(
+  stdout: string,
+  maxFiles: number,
+): Types.NumstatResult {
+  const files: Types.FileStat[] = []
+  const stats = { filesCount: 0, linesAdded: 0, linesRemoved: 0 }
+  const records = stdout.split('\0')
+
+  let at = 0
+
+  while (at < records.length) {
+    const [addedField, removedField, ...pathFields] = (records[at] ?? '').split(
+      '\t',
+    )
+
+    const inline = pathFields.join('\t')
+    const isRename = pathFields.length === 1 && inline === ''
+    const renamedFrom = isRename ? (records[at + 1] ?? null) : null
+    const path = isRename ? (records[at + 2] ?? '') : inline
+    at += isRename ? RENAME_RECORDS : 1
+
+    const isRow =
+      addedField !== undefined && removedField !== undefined && path !== ''
+
+    if (!isRow) {
+      continue
+    }
+
+    const isBinary = addedField === '-' || removedField === '-'
+    const added = isBinary ? 0 : Number(addedField) || 0
+    const removed = isBinary ? 0 : Number(removedField) || 0
+
+    stats.filesCount += 1
+    stats.linesAdded += added
+    stats.linesRemoved += removed
+
+    if (files.length < maxFiles) {
+      files.push({
+        path,
+        renamedFrom,
+        added,
+        removed,
+        isBinary,
+        isUntracked: false,
+        isPreSession: false,
+      })
+    }
+  }
+
+  return { stats, files }
+}