git-chopstick-core 0.1.2 → 0.1.4

package/src/git/log.ts

@@ -1,376 +0,0 @@
-import { git } from './core.js'
-import {
-  CommittedFileChange,
-  AppFileStatusKind,
-  PlainFileStatus,
-  CopiedOrRenamedFileStatus,
-  UntrackedFileStatus,
-  AppFileStatus,
-  SubmoduleStatus,
-} from '../models/status.js'
-import { Repository } from '../models/repository.js'
-import { Commit } from '../models/commit.js'
-import { CommitIdentity } from '../models/commit-identity.js'
-import { parseRawUnfoldedTrailers } from './interpret-trailers.js'
-import { createLogParser } from './git-delimiter-parser.js'
-import { forceUnwrap } from '../lib/fatal-error.js'
-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

@@ -1,42 +0,0 @@
-import { Branch } from '../models/branch.js'
-import { ComputedAction } from '../models/computed-action.js'
-import { Repository } from '../models/repository.js'
-import { git, isGitError } from './core.js'
-import { GitError } from './exec.js'
-
-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

@@ -1,154 +0,0 @@
-import { join } from 'path'
-import { git, HookCallbackOptions } from './core.js'
-import { GitError } from './exec.js'
-import { Repository } from '../models/repository.js'
-import { pathExists } from '../lib/path-exists.js'
-import { createMultiOperationTerminalOutputCallback } from './multi-operation-terminal-output.js'
-
-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

@@ -1,68 +0,0 @@
-import noop from '../lib/noop.js'
-import {
-  TerminalOutput,
-  TerminalOutputCallback,
-  TerminalOutputListener,
-} from './core.js'
-import { pushTerminalChunk } from './push-terminal-chunk.js'
-
-/**
- * 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
-}