git-chopstick-core 0.1.2 → 0.1.4

package/src/git/tag.ts

@@ -1,134 +0,0 @@
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-import { IRemote } from '../models/remote.js'
-import { envForRemoteOperation } from './environment.js'
-
-/**
- * Create a new tag on the given target commit.
- *
- * @param repository        - The repository in which to create the new tag.
- * @param name              - The name of the new tag.
- * @param targetCommitSha   - The SHA of the commit where the new tag will live on.
- */
-export async function createTag(
-  repository: Repository,
-  name: string,
-  targetCommitSha: string
-): Promise<void> {
-  const args = ['tag', '-a', '-m', '', name, targetCommitSha]
-
-  await git(args, repository.path, 'createTag')
-}
-
-/**
- * Delete a tag.
- *
- * @param repository        - The repository in which to create the new tag.
- * @param name              - The name of the tag to delete.
- */
-export async function deleteTag(
-  repository: Repository,
-  name: string
-): Promise<void> {
-  const args = ['tag', '-d', name]
-
-  await git(args, repository.path, 'deleteTag')
-}
-
-/**
- * Gets all the local tags. Returns a Map with the tag name and the commit it points to.
- *
- * @param repository    The repository in which to get all the tags from.
- */
-export async function getAllTags(
-  repository: Repository
-): Promise<Map<string, string>> {
-  const args = ['show-ref', '--tags', '-d']
-
-  const tags = await git(args, repository.path, 'getAllTags', {
-    successExitCodes: new Set([0, 1]), // when there are no tags, git exits with 1.
-  })
-
-  const tagsArray: Array<[string, string]> = tags.stdout
-    .split('\n')
-    .filter(line => line !== '')
-    .map(line => {
-      const [commitSha, rawTagName] = line.split(' ')
-
-      // Normalize tag names by removing the leading ref/tags/ and the trailing ^{}.
-      //
-      // git show-ref returns two entries for annotated tags:
-      // deadbeef refs/tags/annotated-tag
-      // de510b99 refs/tags/annotated-tag^{}
-      //
-      // The first entry sha correspond to the blob object of the annotation, while the second
-      // entry corresponds to the actual commit where the tag was created.
-      // By normalizing the tag name we can make sure that the commit sha gets stored in the returned
-      // Map of commits (since git will always print the entry with the commit sha at the end).
-      const tagName = rawTagName
-        .replace(/^refs\/tags\//, '')
-        .replace(/\^\{\}$/, '')
-
-      return [tagName, commitSha]
-    })
-
-  return new Map(tagsArray)
-}
-
-/**
- * Fetches the tags that will get pushed to the remote repository (it does a network request).
- *
- * @param repository  - The repository in which to check for unpushed tags
- * @param account     - The account to use when authenticating with the remote
- * @param remote      - The remote to check for unpushed tags
- * @param branchName  - The branch that will be used on the push command
- */
-export async function fetchTagsToPush(
-  repository: Repository,
-  remote: IRemote,
-  branchName: string
-): Promise<ReadonlyArray<string>> {
-  const args = [
-    'push',
-    remote.name,
-    branchName,
-    '--follow-tags',
-    '--dry-run',
-    '--no-verify',
-    '--porcelain',
-  ]
-
-  const result = await git(args, repository.path, 'fetchTagsToPush', {
-    env: await envForRemoteOperation(remote.url),
-    successExitCodes: new Set([0, 1, 128]),
-  })
-
-  if (result.exitCode !== 0 && result.exitCode !== 1) {
-    // Only when the exit code of git is 0 or 1, its stdout is parseable.
-    // In other cases, we just rethrow the error so our memoization layer
-    // doesn't cache it indefinitely.
-    throw result.gitError
-  }
-
-  const lines = result.stdout.split('\n')
-  let currentLine = 1
-  const unpushedTags = []
-
-  // the last line of this porcelain command is always 'Done'
-  while (currentLine < lines.length && lines[currentLine] !== 'Done') {
-    const line = lines[currentLine]
-    const parts = line.split('\t')
-
-    if (parts[0] === '*' && parts[2] === '[new tag]') {
-      const [tagName] = parts[1].split(':')
-
-      if (tagName !== undefined) {
-        unpushedTags.push(tagName.replace(/^refs\/tags\//, ''))
-      }
-    }
-
-    currentLine++
-  }
-
-  return unpushedTags
-}

package/src/git/update-index.ts

@@ -1,169 +0,0 @@
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-import { DiffSelectionType } from '../models/diff/index.js'
-import { applyPatchToIndex } from './apply.js'
-import {
-  WorkingDirectoryFileChange,
-  AppFileStatusKind,
-} from '../models/status.js'
-
-interface IUpdateIndexOptions {
-  /**
-   * Whether or not to add a file when it exists in the working directory
-   * but not in the index. Defaults to true (note that this differs from the
-   * default behavior of Git which is to ignore new files).
-   *
-   * @default true
-   */
-  add?: boolean
-
-  /**
-   * Whether or not to remove a file when it exists in the index but not
-   * in the working directory. Defaults to true (note that this differs from
-   * the default behavior of Git which is to ignore removed files).
-   *
-   * @default true
-   */
-  remove?: boolean
-
-  /**
-   * Whether or not to forcefully remove a file from the index even though it
-   * exists in the working directory. This implies remove.
-   *
-   * @default false
-   */
-  forceRemove?: boolean
-
-  /**
-   * Whether or not to replace conflicting entries in the index with that of
-   * the working directory. Imagine the following scenario
-   *
-   * $ touch foo && git update-index --add foo && git commit -m 'foo'
-   * $ rm foo && mkdir foo && echo "bar" > foo/bar
-   * $ git update-index --add foo/bar
-   * error: 'foo/bar' appears as both a file and as a directory
-   * error: foo/bar: cannot add to the index - missing --add option?
-   * fatal: Unable to process path foo/bar
-   *
-   * Replace ignores this conflict and overwrites the index with the
-   * newly created directory, causing the original foo file to be deleted
-   * in the index. This behavior matches what `git add` would do in a similar
-   * scenario.
-   *
-   * @default true
-   */
-  replace?: boolean
-}
-
-/**
- * Updates the index with file contents from the working tree. This method
- * is a noop when no paths are provided.
- *
- * @param paths   A list of paths which are to be updated with file contents and
- *                status from the working directory.
- *
- * @param options See the IUpdateIndexOptions interface for more details.
- */
-async function updateIndex(
-  repository: Repository,
-  paths: ReadonlyArray<string>,
-  options: IUpdateIndexOptions = {}
-) {
-  if (paths.length === 0) {
-    return
-  }
-
-  const args = ['update-index']
-
-  if (options.add !== false) {
-    args.push('--add')
-  }
-
-  if (options.remove !== false || options.forceRemove === true) {
-    args.push('--remove')
-  }
-
-  if (options.forceRemove) {
-    args.push('--force-remove')
-  }
-
-  if (options.replace !== false) {
-    args.push('--replace')
-  }
-
-  args.push('-z', '--stdin')
-
-  await git(args, repository.path, 'updateIndex', {
-    stdin: paths.join('\0'),
-  })
-}
-
-/**
- * Stage all the given files by either staging the entire path or by applying
- * a patch.
- *
- * Note that prior to stageFiles the index has been completely reset,
- * the job of this function is to set up the index in such a way that it
- * reflects what the user has selected in the app.
- */
-export async function stageFiles(
-  repository: Repository,
-  files: ReadonlyArray<WorkingDirectoryFileChange>
-): Promise<void> {
-  const normal = []
-  const oldRenamed = []
-  const partial = []
-  const deletedFiles = []
-
-  for (const file of files) {
-    if (file.selection.getSelectionType() === DiffSelectionType.All) {
-      normal.push(file.path)
-      if (file.status.kind === AppFileStatusKind.Renamed) {
-        oldRenamed.push(file.status.oldPath)
-      } else if (file.status.kind === AppFileStatusKind.Deleted) {
-        deletedFiles.push(file.path)
-      }
-    } else {
-      partial.push(file)
-    }
-  }
-
-  // Staging files happens in three steps.
-  //
-  // In the first step we run through all of the renamed files, or
-  // more specifically the source files (old) that were renamed and
-  // forcefully remove them from the index. We do this in order to handle
-  // the scenario where a file has been renamed and a new file has been
-  // created in its original position. Think of it like this
-  //
-  // $ touch foo && git add foo && git commit -m 'foo'
-  // $ git mv foo bar
-  // $ echo "I'm a new foo" > foo
-  //
-  // Now we have a file which is of type Renamed that has its path set
-  // to 'bar' and its oldPath set to 'foo'. But there's a new file called
-  // foo in the repository. So if the user selects the 'foo -> bar' change
-  // but not the new 'foo' file for inclusion in this commit we don't
-  // want to add the new 'foo', we just want to recreate the move in the
-  // index. We do this by forcefully removing the old path from the index
-  // and then later (in step 2) stage the new file.
-  await updateIndex(repository, oldRenamed, { forceRemove: true })
-
-  // In the second step we update the index to match
-  // the working directory in the case of new, modified, deleted,
-  // and copied files as well as the destination paths for renamed
-  // paths.
-  await updateIndex(repository, normal)
-
-  // This third step will only happen if we have files that have been marked
-  // for deletion. This covers us for files that were blown away in the last
-  // updateIndex call
-  await updateIndex(repository, deletedFiles, { forceRemove: true })
-
-  // Finally we run through all files that have partial selections.
-  // We don't care about renamed or not here since applyPatchToIndex
-  // has logic to support that scenario.
-  for (const file of partial) {
-    await applyPatchToIndex(repository, file)
-  }
-}

package/src/git/update-ref.ts

@@ -1,50 +0,0 @@
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-
-/**
- * Update the ref to a new value.
- *
- * @param repository - The repository in which the ref exists.
- * @param ref        - The ref to update. Must be fully qualified
- *                     (e.g., `refs/heads/NAME`).
- * @param oldValue   - The value we expect the ref to have currently. If it
- *                     doesn't match, the update will be aborted.
- * @param newValue   - The new value for the ref.
- * @param reason     - The reflog entry.
- */
-export async function updateRef(
-  repository: Repository,
-  ref: string,
-  oldValue: string,
-  newValue: string,
-  reason: string
-): Promise<void> {
-  await git(
-    ['update-ref', ref, newValue, oldValue, '-m', reason],
-    repository.path,
-    'updateRef'
-  )
-}
-
-/**
- * Remove a ref.
- *
- * @param repository - The repository in which the ref exists.
- * @param ref        - The ref to remove. Should be fully qualified, but may also be 'HEAD'.
- * @param reason     - The reflog entry (optional). Note that this is only useful when
- *                     deleting the HEAD reference as deleting any other reference will
- *                     implicitly delete the reflog file for that reference as well.
- */
-export async function deleteRef(
-  repository: Repository,
-  ref: string,
-  reason?: string
-) {
-  const args = ['update-ref', '-d', ref]
-
-  if (reason !== undefined) {
-    args.push('-m', reason)
-  }
-
-  await git(args, repository.path, 'deleteRef')
-}

package/src/git/var.ts

@@ -1,42 +0,0 @@
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-import { CommitIdentity } from '../models/commit-identity.js'
-
-/**
- * Gets the author identity, ie the name and email which would
- * have been used should a commit have been performed in this
- * instance. This differs from what's stored in the user.name
- * and user.email config variables in that it will match what
- * Git itself will use in a commit even if there's no name or
- * email configured. If no email or name is configured Git will
- * attempt to come up with a suitable replacement using the
- * signed-in system user and hostname.
- *
- * A null return value means that no name/and or email was set
- * and the user.useconfigonly setting prevented Git from making
- * up a user ident string. If this returns null any subsequent
- * commits can be expected to fail as well.
- */
-export async function getAuthorIdentity(
-  repository: Repository
-): Promise<CommitIdentity | null> {
-  const result = await git(
-    ['var', 'GIT_AUTHOR_IDENT'],
-    repository.path,
-    'getAuthorIdentity',
-    {
-      successExitCodes: new Set([0, 128]),
-    }
-  )
-
-  // If user.user.useconfigonly is set and no user.name or user.email
-  if (result.exitCode === 128) {
-    return null
-  }
-
-  try {
-    return CommitIdentity.parseIdentity(result.stdout)
-  } catch (err) {
-    return null
-  }
-}

package/src/git/worktree-include.ts

@@ -1,146 +0,0 @@
-import * as Fs from 'fs'
-import * as Path from 'path'
-import { readFile, copyFile, mkdir } from 'fs/promises'
-import ignore from 'ignore'
-import type { Repository } from '../models/repository.js'
-import { git } from './core.js'
-import { addWorktree, getMainWorktreePath } from './worktree.js'
-
-const WorktreeIncludeFile = '.worktreeinclude'
-
-/**
- * Reads the patterns from the `.worktreeinclude` file at the root of the
- * given repository path.
- *
- * The file uses `.gitignore` syntax. Blank lines and lines starting with `#`
- * are ignored.
- *
- * Returns an empty array if the file does not exist.
- */
-export async function readWorktreeIncludePatterns(
-  repositoryPath: string
-): Promise<ReadonlyArray<string>> {
-  const filePath = Path.join(repositoryPath, WorktreeIncludeFile)
-
-  let contents: string
-  try {
-    contents = await readFile(filePath, 'utf8')
-  } catch {
-    return []
-  }
-
-  return contents
-    .split('\n')
-    .map(line => line.trim())
-    .filter(line => line.length > 0 && !line.startsWith('#'))
-}
-
-/**
- * Returns the list of gitignored files in `repositoryPath` that match any of
- * the given patterns.
- *
- * Only files that are both gitignored **and** matched by a `.worktreeinclude`
- * pattern are returned — tracked files are never included.
- */
-export async function getIgnoredFilesMatchingPatterns(
-  repository: Repository,
-  patterns: ReadonlyArray<string>
-): Promise<ReadonlyArray<string>> {
-  if (patterns.length === 0) {
-    return []
-  }
-
-  const result = await git(
-    ['ls-files', '--others', '--ignored', '--exclude-standard', '-z'],
-    repository.path,
-    'getIgnoredFiles'
-  )
-
-  // Files are NUL-separated; filter out empty entries from the split
-  const ignoredFiles = result.stdout.split('\0').filter(f => f.length > 0)
-
-  const ig = ignore().add(patterns)
-  return ignoredFiles.filter(f => ig.ignores(f))
-}
-
-/**
- * Copies each file in `files` (relative paths) from `sourcePath` to
- * `destinationPath`, preserving the directory structure.
- *
- * Files that cannot be copied (e.g. because they no longer exist at the
- * source) are skipped silently — a failure to copy a single file never
- * prevents the others from being copied.
- */
-export async function copyWorktreeIncludeFiles(
-  sourcePath: string,
-  destinationPath: string,
-  files: ReadonlyArray<string>
-): Promise<void> {
-  for (const file of files) {
-    const src = Path.join(sourcePath, file)
-    const dest = Path.join(destinationPath, file)
-
-    // Guard against path traversal: the resolved destination must be
-    // inside the worktree directory.
-    const resolvedDest = Path.resolve(dest)
-    const resolvedWorktreeRoot = Path.resolve(destinationPath)
-    if (!resolvedDest.startsWith(resolvedWorktreeRoot + Path.sep)) {
-      continue
-    }
-
-    try {
-      // eslint-disable-next-line no-sync
-      if (!Fs.existsSync(src)) {
-        continue
-      }
-
-      await mkdir(Path.dirname(dest), { recursive: true })
-      await copyFile(src, dest)
-    } catch (e) {
-      console.warn(
-        `[worktree-include] Failed to copy '${file}' to worktree`,
-        e instanceof Error ? e : undefined
-      )
-    }
-  }
-}
-
-/**
- * Creates a new git worktree and then copies any gitignored files listed in
- * the `.worktreeinclude` file from the main worktree into the newly created
- * worktree.
- *
- * The copy step is best-effort: failures are logged but do not prevent the
- * worktree from being used.
- *
- * @param repository  The repository to create the worktree in.
- * @param path        The absolute path where the new worktree should be created.
- * @param options     Options forwarded to `addWorktree`.
- */
-export async function addWorktreeWithIncludes(
-  repository: Repository,
-  path: string,
-  options: Parameters<typeof addWorktree>[2] = {}
-): Promise<void> {
-  await addWorktree(repository, path, options)
-
-  try {
-    const mainPath = (await getMainWorktreePath(repository)) ?? repository.path
-    const patterns = await readWorktreeIncludePatterns(mainPath)
-
-    if (patterns.length === 0) {
-      return
-    }
-
-    const files = await getIgnoredFilesMatchingPatterns(repository, patterns)
-
-    if (files.length > 0) {
-      await copyWorktreeIncludeFiles(mainPath, path, files)
-    }
-  } catch (e) {
-    console.warn(
-      '[worktree-include] Failed to process .worktreeinclude; worktree was still created',
-      e instanceof Error ? e : undefined
-    )
-  }
-}