git-chopstick-core 0.1.1 → 0.1.3

package/src/git/tag.ts

@@ -1,134 +0,0 @@
-import { git } from './core'
-import { Repository } from '../models/repository'
-import { IRemote } from '../models/remote'
-import { envForRemoteOperation } from './environment'
-
-/**
- * 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'
-import { Repository } from '../models/repository'
-import { DiffSelectionType } from '../models/diff'
-import { applyPatchToIndex } from './apply'
-import {
-  WorkingDirectoryFileChange,
-  AppFileStatusKind,
-} from '../models/status'
-
-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/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'
-import { git } from './core'
-import { addWorktree, getMainWorktreePath } from './worktree'
-
-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
-    )
-  }
-}

package/src/git/worktree.ts

@@ -1,219 +0,0 @@
-import { git } from './core'
-import { Repository } from '../models/repository'
-import * as Path from 'path'
-import * as Fs from 'fs'
-import type { WorktreeEntry, WorktreeType } from '../models/worktree'
-import { normalizePath } from '../lib/helpers/path'
-
-/**
- * Get the set of canonical branch refs (e.g. `refs/heads/feature`)
- * checked out in any worktree (main or linked).
- */
-export async function getWorktreeCheckedOutBranches(
-  repository: Repository
-): Promise<ReadonlySet<string>> {
-  const result = await git(
-    ['worktree', 'list', '--porcelain', '-z'],
-    repository.path,
-    'getWorktreeCheckedOutBranches'
-  )
-
-  const branches = new Set<string>()
-
-  // With -z, lines are NUL-terminated and blocks are separated by
-  // double NUL (i.e. an empty string between two NUL terminators).
-  const blocks = result.stdout.split('\0\0')
-
-  for (const block of blocks) {
-    for (const line of block.split('\0')) {
-      if (line.startsWith('branch ')) {
-        branches.add(line.substring('branch '.length))
-      }
-    }
-  }
-
-  return branches
-}
-
-function getDotGitPath(repositoryPath: string): string {
-  return Path.join(repositoryPath, '.git')
-}
-
-export interface IWorktreePathInfo {
-  readonly isLinkedWorktree: boolean
-  readonly mainWorktreePath: string | null
-}
-
-export function parseWorktreePorcelainOutput(
-  stdout: string
-): ReadonlyArray<WorktreeEntry> {
-  if (stdout.trim().length === 0) {
-    return []
-  }
-
-  const blocks = stdout.trim().split('\n\n')
-  const entries: WorktreeEntry[] = []
-
-  for (let i = 0; i < blocks.length; i++) {
-    const lines = blocks[i].split('\n')
-    let path = ''
-    let head = ''
-    let branch: string | null = null
-    let isDetached = false
-    let isLocked = false
-    let isPrunable = false
-
-    for (const line of lines) {
-      if (line.startsWith('worktree ')) {
-        path = line.substring('worktree '.length)
-      } else if (line.startsWith('HEAD ')) {
-        head = line.substring('HEAD '.length)
-      } else if (line.startsWith('branch ')) {
-        branch = line.substring('branch '.length)
-      } else if (line === 'detached') {
-        isDetached = true
-      } else if (line === 'locked' || line.startsWith('locked ')) {
-        isLocked = true
-      } else if (line === 'prunable' || line.startsWith('prunable ')) {
-        isPrunable = true
-      }
-    }
-
-    const type: WorktreeType = i === 0 ? 'main' : 'linked'
-    entries.push({ path, head, branch, isDetached, type, isLocked, isPrunable })
-  }
-
-  return entries
-}
-
-export async function listWorktrees(
-  repository: Repository
-): Promise<ReadonlyArray<WorktreeEntry>> {
-  const result = await git(
-    ['worktree', 'list', '--porcelain'],
-    repository.path,
-    'listWorktrees'
-  )
-
-  return parseWorktreePorcelainOutput(result.stdout)
-}
-
-export async function addWorktree(
-  repository: Repository,
-  path: string,
-  options: {
-    readonly branch?: string
-    readonly createBranch?: string
-    readonly detach?: boolean
-    readonly commitish?: string
-  } = {}
-): Promise<void> {
-  const args = ['worktree', 'add']
-
-  if (options.detach) {
-    args.push('--detach')
-  }
-
-  if (options.createBranch) {
-    args.push('-b', options.createBranch)
-  }
-
-  args.push(path)
-
-  if (options.branch) {
-    args.push(options.branch)
-  } else if (options.commitish) {
-    args.push(options.commitish)
-  }
-
-  await git(args, repository.path, 'addWorktree')
-}
-
-export async function removeWorktree(
-  repository: Repository,
-  path: string
-): Promise<void> {
-  const args = ['worktree', 'remove', '--force', path]
-  await git(args, repository.path, 'removeWorktree')
-}
-
-export async function pruneWorktrees(repository: Repository): Promise<void> {
-  await git(['worktree', 'prune'], repository.path, 'pruneWorktrees')
-}
-
-export async function moveWorktree(
-  repository: Repository,
-  oldPath: string,
-  newPath: string
-): Promise<void> {
-  await git(
-    ['worktree', 'move', oldPath, newPath],
-    repository.path,
-    'moveWorktree'
-  )
-}
-
-export async function isLinkedWorktree(
-  repository: Repository
-): Promise<boolean> {
-  const worktrees = await listWorktrees(repository)
-  const repoPath = normalizePath(repository.path)
-
-  return worktrees.some(
-    wt => wt.type === 'linked' && normalizePath(wt.path) === repoPath
-  )
-}
-
-export async function getMainWorktreePath(
-  repository: Repository
-): Promise<string | null> {
-  const worktrees = await listWorktrees(repository)
-  const main = worktrees.find(wt => wt.type === 'main')
-  return main?.path ?? null
-}
-
-export function getWorktreePathInfoSync(
-  repositoryPath: string
-): IWorktreePathInfo | null {
-  try {
-    const dotGit = getDotGitPath(repositoryPath)
-    // eslint-disable-next-line no-sync
-    const stats = Fs.statSync(dotGit)
-
-    if (stats.isDirectory()) {
-      return { isLinkedWorktree: false, mainWorktreePath: repositoryPath }
-    }
-
-    if (!stats.isFile()) {
-      return null
-    }
-
-    // eslint-disable-next-line no-sync
-    const contents = Fs.readFileSync(dotGit, 'utf8').trim()
-    if (!contents.startsWith('gitdir: ')) {
-      return null
-    }
-
-    const gitDirPath = Path.resolve(
-      repositoryPath,
-      contents.substring('gitdir: '.length)
-    )
-
-    // eslint-disable-next-line no-sync
-    const commondir = Fs.readFileSync(
-      Path.join(gitDirPath, 'commondir'),
-      'utf8'
-    ).trim()
-    if (commondir.length === 0) {
-      return null
-    }
-
-    const commonGitDir = Path.resolve(gitDirPath, commondir)
-    return {
-      isLinkedWorktree: true,
-      mainWorktreePath: Path.dirname(commonGitDir),
-    }
-  } catch {
-    return null
-  }
-}

package/src/index.ts

@@ -1,23 +0,0 @@
-// ── Runtime: Core git operations ──
-export { Repository } from './models/repository.js'
-export { getStatus } from './git/status.js'
-export { getCommits, getChangedFiles } from './git/log.js'
-export { getBranches } from './git/for-each-ref.js'
-export { getRemotes } from './git/remote.js'
-
-// ── Models (classes used both as values and types) ──
-export { Commit } from './models/commit.js'
-export { CommitIdentity } from './models/commit-identity.js'
-export { Branch, BranchType } from './models/branch.js'
-export {
-  CommittedFileChange,
-  WorkingDirectoryFileChange,
-  WorkingDirectoryStatus,
-  AppFileStatusKind,
-} from './models/status.js'
-export { DiffSelection, DiffSelectionType } from './models/diff/diff-selection.js'
-
-// ── Exclusively types ──
-export type { IStatusResult } from './git/status.js'
-export type { IChangesetData } from './git/log.js'
-export type { IRemote } from './models/remote.js'

package/src/lib/api.ts

@@ -1,7 +0,0 @@
-export function getHTMLURL(): string {
-  return 'https://github.com'
-}
-
-export function isTrustedRemoteHost(_url: string): boolean {
-  return true
-}