git-chopstick-core 0.1.0

package/src/git/log.ts

@@ -0,0 +1,376 @@
+import { git } from './core'
+import {
+  CommittedFileChange,
+  AppFileStatusKind,
+  PlainFileStatus,
+  CopiedOrRenamedFileStatus,
+  UntrackedFileStatus,
+  AppFileStatus,
+  SubmoduleStatus,
+} from '../models/status'
+import { Repository } from '../models/repository'
+import { Commit } from '../models/commit'
+import { CommitIdentity } from '../models/commit-identity'
+import { parseRawUnfoldedTrailers } from './interpret-trailers'
+import { createLogParser } from './git-delimiter-parser'
+import { forceUnwrap } from '../lib/fatal-error'
+import assert from 'assert'
+
+// File mode 160000 is used by git specifically for submodules:
+// https://github.com/git/git/blob/v2.37.3/cache.h#L62-L69
+const SubmoduleFileMode = '160000'
+
+function mapSubmoduleStatusFileModes(
+  status: string,
+  srcMode: string,
+  dstMode: string
+): SubmoduleStatus | undefined {
+  return srcMode === SubmoduleFileMode &&
+    dstMode === SubmoduleFileMode &&
+    status === 'M'
+    ? {
+        commitChanged: true,
+        untrackedChanges: false,
+        modifiedChanges: false,
+      }
+    : (srcMode === SubmoduleFileMode && status === 'D') ||
+      (dstMode === SubmoduleFileMode && status === 'A')
+    ? {
+        commitChanged: false,
+        untrackedChanges: false,
+        modifiedChanges: false,
+      }
+    : undefined
+}
+
+/**
+ * Map the raw status text from Git to an app-friendly value
+ * shamelessly borrowed from GitHub Desktop (Windows)
+ */
+function mapStatus(
+  rawStatus: string,
+  oldPath: string | undefined,
+  srcMode: string,
+  dstMode: string
+): PlainFileStatus | CopiedOrRenamedFileStatus | UntrackedFileStatus {
+  const status = rawStatus.trim()
+  const submoduleStatus = mapSubmoduleStatusFileModes(status, srcMode, dstMode)
+
+  if (status === 'M') {
+    return { kind: AppFileStatusKind.Modified, submoduleStatus }
+  } // modified
+  if (status === 'A') {
+    return { kind: AppFileStatusKind.New, submoduleStatus }
+  } // added
+  if (status === '?') {
+    return { kind: AppFileStatusKind.Untracked, submoduleStatus }
+  } // untracked
+  if (status === 'D') {
+    return { kind: AppFileStatusKind.Deleted, submoduleStatus }
+  } // deleted
+  if (status === 'R' && oldPath != null) {
+    return {
+      kind: AppFileStatusKind.Renamed,
+      oldPath,
+      submoduleStatus,
+      renameIncludesModifications: false,
+    }
+  } // renamed
+  if (status === 'C' && oldPath != null) {
+    return {
+      kind: AppFileStatusKind.Copied,
+      oldPath,
+      submoduleStatus,
+      renameIncludesModifications: false,
+    }
+  } // copied
+
+  // git log -M --name-status will return a RXXX - where XXX is a percentage
+  if (status.match(/R[0-9]+/) && oldPath != null) {
+    return {
+      kind: AppFileStatusKind.Renamed,
+      oldPath,
+      submoduleStatus,
+      renameIncludesModifications: status !== 'R100',
+    }
+  }
+
+  // git log -C --name-status will return a CXXX - where XXX is a percentage
+  if (status.match(/C[0-9]+/) && oldPath != null) {
+    return {
+      kind: AppFileStatusKind.Copied,
+      oldPath,
+      submoduleStatus,
+      renameIncludesModifications: false,
+    }
+  }
+
+  return { kind: AppFileStatusKind.Modified, submoduleStatus }
+}
+
+const isCopyOrRename = (
+  status: AppFileStatus
+): status is CopiedOrRenamedFileStatus =>
+  status.kind === AppFileStatusKind.Copied ||
+  status.kind === AppFileStatusKind.Renamed
+
+/**
+ * Get the repository's commits using `revisionRange` and limited to `limit`
+ */
+export async function getCommits(
+  repository: Repository,
+  revisionRange?: string,
+  limit?: number,
+  skip?: number,
+  additionalArgs: ReadonlyArray<string> = []
+): Promise<ReadonlyArray<Commit>> {
+  const { formatArgs, parse } = createLogParser({
+    sha: '%H', // SHA
+    shortSha: '%h', // short SHA
+    summary: '%s', // summary
+    body: '%b', // body
+    // author identity string, matching format of GIT_AUTHOR_IDENT.
+    //   author name <author email> <author date>
+    // author date format dependent on --date arg, should be raw
+    author: '%an <%ae> %ad',
+    committer: '%cn <%ce> %cd',
+    parents: '%P', // parent SHAs,
+    trailers: '%(trailers:unfold,only)',
+    refs: '%D',
+  })
+
+  const args = ['log']
+
+  if (revisionRange !== undefined) {
+    args.push(revisionRange)
+  }
+
+  args.push('--date=raw')
+
+  if (limit !== undefined) {
+    args.push(`--max-count=${limit}`)
+  }
+
+  if (skip !== undefined) {
+    args.push(`--skip=${skip}`)
+  }
+
+  args.push(
+    ...formatArgs,
+    '--no-show-signature',
+    '--no-color',
+    ...additionalArgs,
+    '--'
+  )
+  const result = await git(args, repository.path, 'getCommits', {
+    successExitCodes: new Set([0, 128]),
+    encoding: 'buffer',
+  })
+
+  // if the repository has an unborn HEAD, return an empty history of commits
+  if (result.exitCode === 128) {
+    return new Array<Commit>()
+  }
+
+  const parsed = parse(result.stdout)
+
+  return parsed.map(commit => {
+    // Ref is of the format: (HEAD -> master, tag: some-tag-name, tag: some-other-tag,with-a-comma, origin/master, origin/HEAD)
+    // Refs are comma separated, but some like tags can also contain commas in the name, so we split on the pattern ", " and then
+    // check each ref for the tag prefix. We used to use the regex /tag: ([^\s,]+)/g)`, but will clip a tag with a comma short.
+    const tags = commit.refs
+      .toString()
+      .split(', ')
+      .flatMap(ref => (ref.startsWith('tag: ') ? ref.substring(5) : []))
+
+    return new Commit(
+      commit.sha.toString(),
+      commit.shortSha.toString(),
+      commit.summary.subarray(0, 100 * 1024).toString(),
+      commit.body.subarray(0, 100 * 1024).toString(),
+      CommitIdentity.parseIdentity(commit.author.toString()),
+      CommitIdentity.parseIdentity(commit.committer.toString()),
+      commit.parents.length > 0 ? commit.parents.toString().split(' ') : [],
+      // We know for sure that the trailer separator will be ':' since we got
+      // them from %(trailers:unfold) above, see `git help log`:
+      //
+      //   "key_value_separator=<SEP>: specify a separator inserted between
+      //    trailer lines. When this option is not given each trailer key-value
+      //    pair is separated by ": ". Otherwise it shares the same semantics as
+      //    separator=<SEP> above."
+      parseRawUnfoldedTrailers(commit.trailers.toString(), ':'),
+      tags
+    )
+  })
+}
+
+/** This interface contains information of a changeset. */
+export interface IChangesetData {
+  /** Files changed in the changeset. */
+  readonly files: ReadonlyArray<CommittedFileChange>
+
+  /** Number of lines added in the changeset. */
+  readonly linesAdded: number
+
+  /** Number of lines deleted in the changeset. */
+  readonly linesDeleted: number
+}
+
+/** Get the files that were changed in the given commit. */
+export async function getChangedFiles(
+  repository: Repository,
+  sha: string
+): Promise<IChangesetData> {
+  // opt-in for rename detection (-M) and copies detection (-C)
+  // this is equivalent to the user configuring 'diff.renames' to 'copies'
+  // NOTE: order here matters - doing -M before -C means copies aren't detected
+  const args = [
+    'log',
+    sha,
+    '-C',
+    '-M',
+    '-m',
+    '-1',
+    '--no-show-signature',
+    '--first-parent',
+    '--raw',
+    '--format=format:',
+    '--numstat',
+    '-z',
+    '--',
+  ]
+
+  const { stdout } = await git(args, repository.path, 'getChangesFiles')
+  return parseRawLogWithNumstat(stdout, sha, `${sha}^`)
+}
+
+/**
+ * Parses output of diff flags -z --raw --numstat.
+ *
+ * Given the -z flag the new lines are separated by \0 character (left them as
+ * new lines below for ease of reading)
+ *
+ * For modified, added, deleted, untracked:
+ *    100644 100644 5716ca5 db3c77d M
+ *    file_one_path
+ *    :100644 100644 0835e4f 28096ea M
+ *    file_two_path
+ *    1    0       file_one_path
+ *    1    0       file_two_path
+ *
+ * For copied or renamed:
+ *    100644 100644 5716ca5 db3c77d M
+ *    file_one_original_path
+ *    file_one_new_path
+ *    :100644 100644 0835e4f 28096ea M
+ *    file_two_original_path
+ *    file_two_new_path
+ *    1    0
+ *    file_one_original_path
+ *    file_one_new_path
+ *    1    0
+ *    file_two_original_path
+ *    file_two_new_path
+ */
+
+export function parseRawLogWithNumstat(
+  stdout: string,
+  sha: string,
+  parentCommitish: string
+) {
+  const files = new Array<CommittedFileChange>()
+  let linesAdded = 0
+  let linesDeleted = 0
+  let numStatCount = 0
+  const lines = stdout.split('\0')
+
+  for (let i = 0; i < lines.length - 1; i++) {
+    const line = lines[i]
+    if (line.startsWith(':')) {
+      const lineComponents = line.split(' ')
+      const srcMode = forceUnwrap(
+        'Invalid log output (srcMode)',
+        lineComponents[0]?.replace(':', '')
+      )
+      const dstMode = forceUnwrap(
+        'Invalid log output (dstMode)',
+        lineComponents[1]
+      )
+      const status = forceUnwrap(
+        'Invalid log output (status)',
+        lineComponents.at(-1)
+      )
+      const oldPath = /^R|C/.test(status)
+        ? forceUnwrap('Missing old path', lines.at(++i))
+        : undefined
+
+      const path = forceUnwrap('Missing path', lines.at(++i))
+
+      files.push(
+        new CommittedFileChange(
+          path,
+          mapStatus(status, oldPath, srcMode, dstMode),
+          sha,
+          parentCommitish
+        )
+      )
+    } else {
+      const match = /^(\d+|-)\t(\d+|-)\t/.exec(line)
+      const [, added, deleted] = forceUnwrap('Invalid numstat line', match)
+      linesAdded += added === '-' ? 0 : parseInt(added, 10)
+      linesDeleted += deleted === '-' ? 0 : parseInt(deleted, 10)
+
+      // If this entry denotes a rename or copy the old and new paths are on
+      // two separate fields (separated by \0). Otherwise they're on the same
+      // line as the added and deleted lines.
+      if (isCopyOrRename(files[numStatCount].status)) {
+        i += 2
+      }
+      numStatCount++
+    }
+  }
+
+  return { files, linesAdded, linesDeleted }
+}
+
+/** Get the commit for the given ref. */
+export async function getCommit(
+  repository: Repository,
+  ref: string
+): Promise<Commit | null> {
+  const commits = await getCommits(repository, ref, 1)
+  if (commits.length < 1) {
+    return null
+  }
+
+  return commits[0]
+}
+
+/** Get the author identity for the given shas */
+export async function getAuthors(repository: Repository, shas: string[]) {
+  if (shas.length === 0) {
+    return []
+  }
+
+  const { stdout } = await git(
+    [
+      'log',
+      '--format=format:%an <%ae> %ad',
+      '--no-walk=unsorted',
+      '--date=raw',
+      '-z',
+      '--stdin',
+    ],
+    repository.path,
+    'getAuthors',
+    { stdin: shas.join('\n') }
+  )
+
+  const authors = stdout.split('\0').map(CommitIdentity.parseIdentity)
+
+  // This can happen if there are duplicate shas in the input, git log will only
+  // return the author once for each sha.
+  assert.equal(authors.length, shas.length, 'Commit to author mismatch')
+
+  return authors
+}

package/src/git/merge-tree.ts

@@ -0,0 +1,42 @@
+import { Branch } from '../models/branch'
+import { ComputedAction } from '../models/computed-action'
+import { Repository } from '../models/repository'
+import { git, isGitError } from './core'
+import { GitError } from './exec'
+
+type MergeTreeResult =
+  | { kind: ComputedAction.Clean }
+  | { kind: ComputedAction.Conflicts; conflictedFiles: number }
+  | { kind: ComputedAction.Invalid }
+
+export async function determineMergeability(
+  repository: Repository,
+  ours: Branch,
+  theirs: Branch
+) {
+  return git(
+    [
+      'merge-tree',
+      '--write-tree',
+      '--name-only',
+      '--no-messages',
+      '-z',
+      ours.tip.sha,
+      theirs.tip.sha,
+    ],
+    repository.path,
+    'determineMergeability',
+    { successExitCodes: new Set([0, 1]) }
+  )
+    .then<MergeTreeResult>(({ stdout }) => {
+      const conflictedFiles = (stdout.match(/\0/g)?.length ?? 0) - 1
+      return conflictedFiles > 0
+        ? { kind: ComputedAction.Conflicts, conflictedFiles }
+        : { kind: ComputedAction.Clean }
+    })
+    .catch<MergeTreeResult>(e =>
+      isGitError(e, GitError.CannotMergeUnrelatedHistories)
+        ? Promise.resolve({ kind: ComputedAction.Invalid })
+        : Promise.reject(e)
+    )
+}

package/src/git/merge.ts

@@ -0,0 +1,154 @@
+import { join } from 'path'
+import { git, HookCallbackOptions } from './core'
+import { GitError } from './exec'
+import { Repository } from '../models/repository'
+import { pathExists } from '../lib/path-exists'
+import { createMultiOperationTerminalOutputCallback } from './multi-operation-terminal-output'
+
+export enum MergeResult {
+  /** The merge completed successfully */
+  Success,
+  /**
+   * The merge was a noop since the current branch
+   * was already up to date with the target branch.
+   */
+  AlreadyUpToDate,
+  /**
+   * The merge failed, likely due to conflicts.
+   */
+  Failed,
+}
+
+export type MergeOptions = {
+  /** Whether to perform a squash merge */
+  readonly squash?: boolean
+  /** Whether to bypass pre-merge and post-merge hooks */
+  readonly noVerify?: boolean
+} & HookCallbackOptions
+
+/** Merge the named branch into the current branch. */
+export async function merge(
+  repository: Repository,
+  branch: string,
+  options?: MergeOptions
+): Promise<MergeResult> {
+  const onTerminalOutputAvailable = options?.onTerminalOutputAvailable
+    ? createMultiOperationTerminalOutputCallback(
+        options?.onTerminalOutputAvailable
+      )
+    : undefined
+
+  const args = ['merge']
+
+  if (options?.squash) {
+    args.push('--squash')
+  }
+
+  if (options?.noVerify) {
+    args.push('--no-verify')
+  }
+
+  args.push(branch)
+
+  const { exitCode, stdout } = await git(args, repository.path, 'merge', {
+    expectedErrors: new Set([GitError.MergeConflicts]),
+    interceptHooks: ['pre-merge-commit', 'post-merge', 'commit-msg'],
+    onHookProgress: options?.onHookProgress,
+    onHookFailure: options?.onHookFailure,
+    onTerminalOutputAvailable,
+  })
+
+  if (exitCode !== 0) {
+    return MergeResult.Failed
+  }
+
+  if (options?.squash) {
+    const { exitCode } = await git(
+      ['commit', '--no-edit'],
+      repository.path,
+      'createSquashMergeCommit',
+      {
+        interceptHooks: [
+          'pre-merge-commit',
+          'prepare-commit-msg',
+          'commit-msg',
+          'post-commit',
+          'pre-auto-gc',
+        ],
+        onHookProgress: options?.onHookProgress,
+        onHookFailure: options?.onHookFailure,
+        onTerminalOutputAvailable,
+      }
+    )
+    if (exitCode !== 0) {
+      return MergeResult.Failed
+    }
+  }
+
+  return stdout === noopMergeMessage
+    ? MergeResult.AlreadyUpToDate
+    : MergeResult.Success
+}
+
+const noopMergeMessage = 'Already up to date.\n'
+
+/**
+ * Find the base commit between two commit-ish identifiers
+ *
+ * @returns the commit id of the merge base, or null if the two commit-ish
+ *          identifiers do not have a common base
+ */
+export async function getMergeBase(
+  repository: Repository,
+  firstCommitish: string,
+  secondCommitish: string
+): Promise<string | null> {
+  const process = await git(
+    ['merge-base', firstCommitish, secondCommitish],
+    repository.path,
+    'merge-base',
+    {
+      // - 1 is returned if a common ancestor cannot be resolved
+      // - 128 is returned if a ref cannot be found
+      //   "warning: ignoring broken ref refs/remotes/origin/main."
+      successExitCodes: new Set([0, 1, 128]),
+    }
+  )
+
+  if (process.exitCode === 1 || process.exitCode === 128) {
+    return null
+  }
+
+  return process.stdout.trim()
+}
+
+/**
+ * Abort a mid-flight (conflicted) merge
+ *
+ * @param repository where to abort the merge
+ */
+export async function abortMerge(repository: Repository): Promise<void> {
+  await git(['merge', '--abort'], repository.path, 'abortMerge')
+}
+
+/**
+ * Check the `.git/MERGE_HEAD` file exists in a repository to confirm
+ * that it is in a conflicted state.
+ */
+export async function isMergeHeadSet(repository: Repository): Promise<boolean> {
+  const path = join(repository.resolvedGitDir, 'MERGE_HEAD')
+  return await pathExists(path)
+}
+
+/**
+ * Check the `.git/SQUASH_MSG` file exists in a repository
+ * This would indicate we did a merge --squash and have not committed.. indicating
+ * we have detected a conflict.
+ *
+ * Note: If we abort the merge, this doesn't get cleared automatically which
+ * could lead to this being erroneously available in a non merge --squashing scenario.
+ */
+export async function isSquashMsgSet(repository: Repository): Promise<boolean> {
+  const path = join(repository.resolvedGitDir, 'SQUASH_MSG')
+  return await pathExists(path)
+}

package/src/git/multi-operation-terminal-output.ts

@@ -0,0 +1,68 @@
+import noop from '../lib/noop'
+import {
+  TerminalOutput,
+  TerminalOutputCallback,
+  TerminalOutputListener,
+} from './core'
+import { pushTerminalChunk } from './push-terminal-chunk'
+
+/**
+ * Creates a callback that aggregates terminal output from multiple Git
+ * operations into a single stream.
+ *
+ * This function is useful when running multiple Git operations sequentially
+ * where you want to present a unified terminal output view. It buffers output
+ * from all operations and forwards them to upstream subscribers when requested.
+ *
+ * The callback maintains an internal buffer (default 256KB) and subscribes to
+ * each Git operation's terminal output. When an upstream consumer requests the
+ * output, it receives all previously buffered chunks followed by any new chunks
+ * as they arrive.
+ *
+ * @param onTerminalOutputAvailable - The user provided callback which will
+ *                                    receive the aggregated terminal output.
+ * @returns A callback that can be passed to individual Git operations as the
+ *          onTerminalOutputAvailable callback to capture their terminal output
+ */
+export const createMultiOperationTerminalOutputCallback = (
+  onTerminalOutputAvailable: TerminalOutputCallback,
+  capacity = 256 * 1024
+): TerminalOutputCallback => {
+  let outputStarted = false
+  const chunks: string[] = []
+  const upstreamSubscribers = new Set<(chunk: TerminalOutput) => void>()
+
+  const push = (chunk: string | Buffer) => {
+    if (!outputStarted) {
+      onTerminalOutputAvailable(function (cb) {
+        upstreamSubscribers.add(cb)
+        chunks.forEach(c => cb(c))
+        return { unsubscribe: () => upstreamSubscribers.delete(cb) }
+      })
+      outputStarted = true
+    }
+
+    pushTerminalChunk(chunks, capacity, chunk)
+    upstreamSubscribers.forEach(cb => cb(chunk))
+  }
+
+  // Called by each Git operation when terminal output is available. We'll
+  // subscribe immediately to capture output from all operations and then
+  // forward it to upstream callbacks if/when requested.
+  const cb = function (subscribe: TerminalOutputListener) {
+    subscribe(c => {
+      if (Array.isArray(c)) {
+        chunks.forEach(push)
+      } else {
+        push(c)
+      }
+    })
+
+    // We can't unsubscribe because the user might request terminal output in
+    // the future and we need to buffer the output from all operations to
+    // ensure we can present the entire output.
+    return { unsubscribe: noop }
+  }
+
+  return cb
+}