git-chopstick-core 0.1.0

package/src/git/pull.ts

@@ -0,0 +1,130 @@
+import {
+  git,
+  gitRebaseArguments,
+  HookProgress,
+  IGitStringExecutionOptions,
+  TerminalOutput,
+  TerminalOutputCallback,
+} from './core'
+import { Repository } from '../models/repository'
+import { IPullProgress } from '../models/progress'
+import { PullProgressParser, executionOptionsWithProgress } from '../lib/progress'
+import { IRemote } from '../models/remote'
+import { envForRemoteOperation } from './environment'
+import { getConfigValue } from './config'
+
+/**
+ * Pull from the specified remote.
+ *
+ * @param repository - The repository in which the pull should take place
+ *
+ * @param remote     - The name of the remote that should be pulled from
+ *
+ * @param progressCallback - An optional function which will be invoked
+ *                           with information about the current progress
+ *                           of the pull operation. When provided this enables
+ *                           the '--progress' command line flag for
+ *                           'git pull'.
+ */
+export async function pull(
+  repository: Repository,
+  remote: IRemote,
+  options?: {
+    progressCallback?: (progress: IPullProgress) => void
+    onHookProgress?: (progress: HookProgress) => void
+    onHookFailure?: (
+      hookName: string,
+      terminalOutput: TerminalOutput
+    ) => Promise<'abort' | 'ignore'>
+    onTerminalOutputAvailable?: TerminalOutputCallback
+    noVerify?: boolean
+  }
+): Promise<void> {
+  let opts: IGitStringExecutionOptions = {
+    env: await envForRemoteOperation(remote.url),
+    // git pull triggers merge or rebase hooks depending on config, instead of
+    // trying to check pull.rebase and friends we'll just intercept all possible
+    // hooks that could be run as part of a pull operation.
+    interceptHooks: [
+      'pre-merge-commit',
+      'prepare-commit-msg',
+      'commit-msg',
+      'post-merge',
+      'pre-rebase',
+      'pre-commit',
+      'post-rewrite',
+    ],
+  }
+
+  if (options?.progressCallback) {
+    const title = `Pulling ${remote.name}`
+    const kind = 'pull'
+
+    opts = await executionOptionsWithProgress(
+      { ...opts, trackLFSProgress: true },
+      new PullProgressParser(),
+      progress => {
+        // In addition to progress output from the remote end and from
+        // git itself, the stderr output from pull contains information
+        // about ref updates. We don't need to bring those into the progress
+        // stream so we'll just punt on anything we don't know about for now.
+        if (progress.kind === 'context') {
+          if (!progress.text.startsWith('remote: Counting objects')) {
+            return
+          }
+        }
+
+        const description =
+          progress.kind === 'progress' ? progress.details.text : progress.text
+
+        const value = progress.percent
+
+        options?.progressCallback?.({
+          kind,
+          title,
+          description,
+          value,
+          remote: remote.name,
+        })
+      }
+    )
+
+    // Initial progress
+    options.progressCallback({ kind, title, value: 0, remote: remote.name })
+  }
+
+  const args = [
+    ...gitRebaseArguments(),
+    'pull',
+    ...(await getDefaultPullDivergentBranchArguments(repository)),
+    '--recurse-submodules',
+    ...(options?.progressCallback ? ['--progress'] : []),
+    ...(options?.noVerify ? ['--no-verify'] : []),
+    remote.name,
+  ]
+
+  await git(args, repository.path, 'pull', opts)
+}
+
+/**
+ * Defaults the pull default for divergent paths to try to fast forward and if
+ * not perform a merge. Aka uses the flag --ff
+ *
+ * It checks whether the user has a config set for this already, if so, no need for
+ * default.
+ */
+async function getDefaultPullDivergentBranchArguments(
+  repository: Repository
+): Promise<ReadonlyArray<string>> {
+  try {
+    const pullFF = await getConfigValue(repository, 'pull.ff')
+    return pullFF !== null ? [] : ['--ff']
+  } catch (e) {
+    console.error("Couldn't read 'pull.ff' config", e)
+  }
+
+  // If there is a failure in checking the config, we still want to use any
+  // config and not overwrite the user's set config behavior. This will show the
+  // git error if no config is set.
+  return []
+}

package/src/git/push-terminal-chunk.ts

@@ -0,0 +1,41 @@
+import { coerceToString } from './coerce-to-string'
+
+/**
+ * Appends a chunk of terminal output to a buffer while maintaining a maximum capacity.
+ *
+ * This function manages a rolling buffer of terminal output (combined stdout and stderr)
+ * by pushing new chunks and trimming from the beginning when the total character count
+ * exceeds the specified capacity. This ensures memory-bounded storage of terminal output
+ * for git operations.
+ *
+ * @param chunks - The array of string chunks representing the terminal output buffer.
+ *                 This array is mutated in place.
+ * @param capacity - The maximum number of characters to retain in the buffer.
+ *                   Note: this is character count, not byte count.
+ * @param chunk - The new chunk of terminal output to append, either as a Buffer or string.
+ *
+ * Intended to be used by git operations in core.ts to capture and limit terminal output.
+ * When the buffer exceeds capacity, chunks are removed from the beginning (oldest first),
+ * and partial chunks may be trimmed to fit exactly within the capacity limit.
+ */
+export const pushTerminalChunk = (
+  chunks: string[],
+  capacity: number,
+  chunk: Buffer | string
+) => {
+  chunks.push(coerceToString(chunk))
+  let terminalOutputLength = chunks.reduce((acc, cur) => acc + cur.length, 0)
+
+  while (terminalOutputLength > capacity) {
+    const firstChunk = chunks[0]
+    const overrun = terminalOutputLength - capacity
+
+    if (overrun >= firstChunk.length) {
+      chunks.shift()
+      terminalOutputLength -= firstChunk.length
+    } else {
+      chunks[0] = firstChunk.substring(overrun)
+      terminalOutputLength -= overrun
+    }
+  }
+}

package/src/git/push.ts

@@ -0,0 +1,119 @@
+import { git, HookCallbackOptions, IGitStringExecutionOptions } from './core'
+import { Repository } from '../models/repository'
+import { IPushProgress } from '../models/progress'
+import { PushProgressParser, executionOptionsWithProgress } from '../lib/progress'
+import { IRemote } from '../models/remote'
+import { envForRemoteOperation } from './environment'
+import { Branch } from '../models/branch'
+
+export type PushOptions = {
+  /**
+   * Force-push the branch without losing changes in the remote that
+   * haven't been fetched.
+   *
+   * See https://git-scm.com/docs/git-push#Documentation/git-push.txt---no-force-with-lease
+   */
+  readonly forceWithLease?: boolean
+
+  /** A branch to push instead of the current branch */
+  readonly branch?: Branch
+
+  readonly noVerify?: boolean
+} & HookCallbackOptions
+
+/**
+ * Push from the remote to the branch, optionally setting the upstream.
+ *
+ * @param repository - The repository from which to push
+ *
+ * @param account - The account to use when authenticating with the remote
+ *
+ * @param remote - The remote to push the specified branch to
+ *
+ * @param localBranch - The local branch to push
+ *
+ * @param remoteBranch - The remote branch to push to
+ *
+ * @param tagsToPush - The tags to push along with the branch.
+ *
+ * @param options - Optional customizations for the push execution.
+ *                  see PushOptions for more information.
+ *
+ * @param progressCallback - An optional function which will be invoked
+ *                           with information about the current progress
+ *                           of the push operation. When provided this enables
+ *                           the '--progress' command line flag for
+ *                           'git push'.
+ */
+export async function push(
+  repository: Repository,
+  remote: IRemote,
+  localBranch: string,
+  remoteBranch: string | null,
+  tagsToPush: ReadonlyArray<string> | null,
+  options?: PushOptions,
+  progressCallback?: (progress: IPushProgress) => void
+): Promise<void> {
+  const args = [
+    'push',
+    remote.name,
+    remoteBranch ? `${localBranch}:${remoteBranch}` : localBranch,
+  ]
+
+  if (tagsToPush !== null) {
+    args.push(...tagsToPush)
+  }
+  if (!remoteBranch) {
+    args.push('--set-upstream')
+  } else if (options?.forceWithLease) {
+    args.push('--force-with-lease')
+  }
+
+  if (options?.noVerify) {
+    args.push('--no-verify')
+  }
+
+  let opts: IGitStringExecutionOptions = {
+    env: await envForRemoteOperation(remote.url),
+    interceptHooks: ['pre-push'],
+    onHookProgress: options?.onHookProgress,
+    onHookFailure: options?.onHookFailure,
+    onTerminalOutputAvailable: options?.onTerminalOutputAvailable,
+  }
+
+  if (progressCallback) {
+    args.push('--progress')
+    const title = `Pushing to ${remote.name}`
+    const kind = 'push'
+
+    opts = await executionOptionsWithProgress(
+      { ...opts, trackLFSProgress: true },
+      new PushProgressParser(),
+      progress => {
+        const description =
+          progress.kind === 'progress' ? progress.details.text : progress.text
+        const value = progress.percent
+
+        progressCallback({
+          kind,
+          title,
+          description,
+          value,
+          remote: remote.name,
+          branch: localBranch,
+        })
+      }
+    )
+
+    // Initial progress
+    progressCallback({
+      kind: 'push',
+      title,
+      value: 0,
+      remote: remote.name,
+      branch: localBranch,
+    })
+  }
+
+  await git(args, repository.path, 'push', opts)
+}