git-chopstick-core 0.1.1 → 0.1.2

package/dist/git/merge.js

@@ -0,0 +1,111 @@
+import { join } from 'path';
+import { git } from './core.js';
+import { GitError } from './exec.js';
+import { pathExists } from '../lib/path-exists.js';
+import { createMultiOperationTerminalOutputCallback } from './multi-operation-terminal-output.js';
+export var MergeResult;
+(function (MergeResult) {
+    /** The merge completed successfully */
+    MergeResult[MergeResult["Success"] = 0] = "Success";
+    /**
+     * The merge was a noop since the current branch
+     * was already up to date with the target branch.
+     */
+    MergeResult[MergeResult["AlreadyUpToDate"] = 1] = "AlreadyUpToDate";
+    /**
+     * The merge failed, likely due to conflicts.
+     */
+    MergeResult[MergeResult["Failed"] = 2] = "Failed";
+})(MergeResult || (MergeResult = {}));
+/** Merge the named branch into the current branch. */
+export async function merge(repository, branch, options) {
+    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, firstCommitish, secondCommitish) {
+    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) {
+    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) {
+    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) {
+    const path = join(repository.resolvedGitDir, 'SQUASH_MSG');
+    return await pathExists(path);
+}
+//# sourceMappingURL=merge.js.map

package/dist/git/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../src/git/merge.ts"],"names":[],"mappings":"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"}

package/dist/git/multi-operation-terminal-output.d.ts

@@ -0,0 +1,20 @@
+import { TerminalOutputCallback } from './core.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 declare const createMultiOperationTerminalOutputCallback: (onTerminalOutputAvailable: TerminalOutputCallback, capacity?: number) => TerminalOutputCallback;

package/dist/git/multi-operation-terminal-output.js

@@ -0,0 +1,56 @@
+import noop from '../lib/noop.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, capacity = 256 * 1024) => {
+    let outputStarted = false;
+    const chunks = [];
+    const upstreamSubscribers = new Set();
+    const push = (chunk) => {
+        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) {
+        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;
+};
+//# sourceMappingURL=multi-operation-terminal-output.js.map

package/dist/git/multi-operation-terminal-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-operation-terminal-output.js","sourceRoot":"","sources":["../../src/git/multi-operation-terminal-output.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,gBAAgB,CAAA;AAMjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAE5D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,0CAA0C,GAAG,CACxD,yBAAiD,EACjD,QAAQ,GAAG,GAAG,GAAG,IAAI,EACG,EAAE;IAC1B,IAAI,aAAa,GAAG,KAAK,CAAA;IACzB,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAmC,CAAA;IAEtE,MAAM,IAAI,GAAG,CAAC,KAAsB,EAAE,EAAE;QACtC,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,yBAAyB,CAAC,UAAU,EAAE;gBACpC,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;gBAC3B,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;gBAC1B,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAA;YAC9D,CAAC,CAAC,CAAA;YACF,aAAa,GAAG,IAAI,CAAA;QACtB,CAAC;QAED,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;QAC1C,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IAC9C,CAAC,CAAA;IAED,wEAAwE;IACxE,uEAAuE;IACvE,sDAAsD;IACtD,MAAM,EAAE,GAAG,UAAU,SAAiC;QACpD,SAAS,CAAC,CAAC,CAAC,EAAE;YACZ,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;gBACrB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YACtB,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,CAAC,CAAC,CAAA;YACT,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,yEAAyE;QACzE,qEAAqE;QACrE,2CAA2C;QAC3C,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,CAAA;IAC9B,CAAC,CAAA;IAED,OAAO,EAAE,CAAA;AACX,CAAC,CAAA"}

package/dist/git/pull.d.ts

@@ -0,0 +1,24 @@
+import { HookProgress, TerminalOutput, TerminalOutputCallback } from './core.js';
+import { Repository } from '../models/repository.js';
+import { IPullProgress } from '../models/progress.js';
+import { IRemote } from '../models/remote.js';
+/**
+ * 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 declare 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>;

package/dist/git/pull.js

@@ -0,0 +1,91 @@
+import { git, gitRebaseArguments, } from './core.js';
+import { PullProgressParser, executionOptionsWithProgress } from '../lib/progress/index.js';
+import { envForRemoteOperation } from './environment.js';
+import { getConfigValue } from './config.js';
+/**
+ * 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, remote, options) {
+    let opts = {
+        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) {
+    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 [];
+}
+//# sourceMappingURL=pull.js.map

package/dist/git/pull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.js","sourceRoot":"","sources":["../../src/git/pull.ts"],"names":[],"mappings":"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"}

package/dist/git/push-terminal-chunk.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 declare const pushTerminalChunk: (chunks: string[], capacity: number, chunk: Buffer | string) => void;

package/dist/git/push-terminal-chunk.js

@@ -0,0 +1,36 @@
+import { coerceToString } from './coerce-to-string.js';
+/**
+ * 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, capacity, chunk) => {
+    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;
+        }
+    }
+};
+//# sourceMappingURL=push-terminal-chunk.js.map

package/dist/git/push-terminal-chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-terminal-chunk.js","sourceRoot":"","sources":["../../src/git/push-terminal-chunk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,MAAgB,EAChB,QAAgB,EAChB,KAAsB,EACtB,EAAE;IACF,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;IAClC,IAAI,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IAE3E,OAAO,oBAAoB,GAAG,QAAQ,EAAE,CAAC;QACvC,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;QAC5B,MAAM,OAAO,GAAG,oBAAoB,GAAG,QAAQ,CAAA;QAE/C,IAAI,OAAO,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YACjC,MAAM,CAAC,KAAK,EAAE,CAAA;YACd,oBAAoB,IAAI,UAAU,CAAC,MAAM,CAAA;QAC3C,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;YACzC,oBAAoB,IAAI,OAAO,CAAA;QACjC,CAAC;IACH,CAAC;AACH,CAAC,CAAA"}

package/dist/git/push.d.ts

@@ -0,0 +1,42 @@
+import { HookCallbackOptions } from './core.js';
+import { Repository } from '../models/repository.js';
+import { IPushProgress } from '../models/progress.js';
+import { IRemote } from '../models/remote.js';
+import { Branch } from '../models/branch.js';
+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 declare function push(repository: Repository, remote: IRemote, localBranch: string, remoteBranch: string | null, tagsToPush: ReadonlyArray<string> | null, options?: PushOptions, progressCallback?: (progress: IPushProgress) => void): Promise<void>;

package/dist/git/push.js

@@ -0,0 +1,80 @@
+import { git } from './core.js';
+import { PushProgressParser, executionOptionsWithProgress } from '../lib/progress/index.js';
+import { envForRemoteOperation } from './environment.js';
+/**
+ * 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, remote, localBranch, remoteBranch, tagsToPush, options, progressCallback) {
+    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 = {
+        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);
+}
+//# sourceMappingURL=push.js.map

package/dist/git/push.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.js","sourceRoot":"","sources":["../../src/git/push.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAmD,MAAM,WAAW,CAAA;AAGhF,OAAO,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAA;AAE3F,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAkBxD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,IAAI,CACxB,UAAsB,EACtB,MAAe,EACf,WAAmB,EACnB,YAA2B,EAC3B,UAAwC,EACxC,OAAqB,EACrB,gBAAoD;IAEpD,MAAM,IAAI,GAAG;QACX,MAAM;QACN,MAAM,CAAC,IAAI;QACX,YAAY,CAAC,CAAC,CAAC,GAAG,WAAW,IAAI,YAAY,EAAE,CAAC,CAAC,CAAC,WAAW;KAC9D,CAAA;IAED,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAA;IAC1B,CAAC;IACD,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;IAC7B,CAAC;SAAM,IAAI,OAAO,EAAE,cAAc,EAAE,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAA;IACjC,CAAC;IAED,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;IAC1B,CAAC;IAED,IAAI,IAAI,GAA+B;QACrC,GAAG,EAAE,MAAM,qBAAqB,CAAC,MAAM,CAAC,GAAG,CAAC;QAC5C,cAAc,EAAE,CAAC,UAAU,CAAC;QAC5B,cAAc,EAAE,OAAO,EAAE,cAAc;QACvC,aAAa,EAAE,OAAO,EAAE,aAAa;QACrC,yBAAyB,EAAE,OAAO,EAAE,yBAAyB;KAC9D,CAAA;IAED,IAAI,gBAAgB,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QACvB,MAAM,KAAK,GAAG,cAAc,MAAM,CAAC,IAAI,EAAE,CAAA;QACzC,MAAM,IAAI,GAAG,MAAM,CAAA;QAEnB,IAAI,GAAG,MAAM,4BAA4B,CACvC,EAAE,GAAG,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,EACnC,IAAI,kBAAkB,EAAE,EACxB,QAAQ,CAAC,EAAE;YACT,MAAM,WAAW,GACf,QAAQ,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAA;YACtE,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAA;YAE9B,gBAAgB,CAAC;gBACf,IAAI;gBACJ,KAAK;gBACL,WAAW;gBACX,KAAK;gBACL,MAAM,EAAE,MAAM,CAAC,IAAI;gBACnB,MAAM,EAAE,WAAW;aACpB,CAAC,CAAA;QACJ,CAAC,CACF,CAAA;QAED,mBAAmB;QACnB,gBAAgB,CAAC;YACf,IAAI,EAAE,MAAM;YACZ,KAAK;YACL,KAAK,EAAE,CAAC;YACR,MAAM,EAAE,MAAM,CAAC,IAAI;YACnB,MAAM,EAAE,WAAW;SACpB,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;AAChD,CAAC"}

package/dist/git/rebase.d.ts

@@ -0,0 +1,119 @@
+import { Repository } from '../models/repository.js';
+import { RebaseInternalState } from '../models/rebase.js';
+import { IMultiCommitOperationProgress } from '../models/progress.js';
+import { WorkingDirectoryFileChange } from '../models/status.js';
+import { ManualConflictResolution } from '../models/manual-conflict-resolution.js';
+import { Commit, CommitOneLine } from '../models/commit.js';
+import { HookCallbackOptions } from './core.js';
+import { Branch } from '../models/branch.js';
+/** The app-specific results from attempting to rebase a repository */
+export declare enum RebaseResult {
+    /**
+     * Git completed the rebase without reporting any errors, and the caller can
+     * signal success to the user.
+     */
+    CompletedWithoutError = "CompletedWithoutError",
+    /**
+     * Git completed the rebase without reporting any errors, but the branch was
+     * already up to date and there was nothing to do.
+     */
+    AlreadyUpToDate = "AlreadyUpToDate",
+    /**
+     * The rebase encountered conflicts while attempting to rebase, and these
+     * need to be resolved by the user before the rebase can continue.
+     */
+    ConflictsEncountered = "ConflictsEncountered",
+    /**
+     * The rebase was not able to continue as tracked files were not staged in
+     * the index.
+     */
+    OutstandingFilesNotStaged = "OutstandingFilesNotStaged",
+    /**
+     * The rebase was not attempted because it could not check the status of the
+     * repository. The caller needs to confirm the repository is in a usable
+     * state.
+     */
+    Aborted = "Aborted",
+    /**
+     * An unexpected error as part of the rebase flow was caught and handled.
+     *
+     * Check the logs to find the relevant Git details.
+     */
+    Error = "Error"
+}
+/**
+ * Get the internal state about the rebase being performed on a repository. This
+ * information is required to help Desktop display information to the user
+ * about the current action as well as the options available.
+ *
+ * Returns `null` if no rebase is detected, or if the expected information
+ * cannot be found in the repository.
+ */
+export declare function getRebaseInternalState(repository: Repository): Promise<RebaseInternalState | null>;
+/**
+ * Inspect the `.git/rebase-merge` folder and convert the current rebase state
+ * into data that can be provided to the rebase flow to update the application
+ * state.
+ *
+ * This is required when Desktop is not responsible for initiating the rebase:
+ *
+ *   - when a rebase outside Desktop encounters conflicts
+ *   - when a `git pull --rebase` was run and encounters conflicts
+ *
+ */
+export declare function getRebaseSnapshot(repository: Repository): Promise<{
+    progress: IMultiCommitOperationProgress;
+    commits: ReadonlyArray<CommitOneLine>;
+} | null>;
+/**
+ * A stub function to use for initiating rebase in the app.
+ *
+ * If the rebase fails, the repository will be in an indeterminate state where
+ * the rebase is stuck.
+ *
+ * If the rebase completes without error, `featureBranch` will be checked out
+ * and it will probably have a different commit history.
+ *
+ * @param baseBranch the ref to start the rebase from
+ * @param targetBranch the ref to rebase onto `baseBranch`
+ */
+export declare function rebase(repository: Repository, baseBranch: Branch, targetBranch: Branch, progressCallback?: (progress: IMultiCommitOperationProgress) => void): Promise<RebaseResult>;
+/** Abandon the current rebase operation */
+export declare function abortRebase(repository: Repository): Promise<void>;
+/**
+ * Proceed with the current rebase operation and report back on whether it completed
+ *
+ * It is expected that the index has staged files which are cleanly rebased onto
+ * the base branch, and the remaining unstaged files are those which need manual
+ * resolution or were changed by the user to address inline conflicts.
+ *
+ */
+export declare function continueRebase(repository: Repository, files: ReadonlyArray<WorkingDirectoryFileChange>, manualResolutions?: ReadonlyMap<string, ManualConflictResolution>, opts?: RebaseInteractiveOptions): Promise<RebaseResult>;
+export type RebaseInteractiveOptions = {
+    /**
+     * a description of the action to be displayed in the progress dialog - i.e. Squash, Amend, etc..
+     */
+    action?: string;
+    /**
+     * the GIT_EDITOR environment variable to use during the interactive rebase,
+     * defaults to ':' which is a no-op command
+     */
+    gitEditor?: string;
+    progressCallback?: (progress: IMultiCommitOperationProgress) => void;
+    commits?: ReadonlyArray<Commit>;
+    noVerify?: boolean;
+} & HookCallbackOptions;
+/**
+ * Method for initiating interactive rebase in the app.
+ *
+ * In order to modify the interactive todo list during interactive rebase, we
+ * create a temporary todo list of our own. Pass that file's path into our
+ * interactive rebase and using the sequence.editor to cat replace the
+ * interactive todo list with the contents of our generated one.
+ *
+ * @param pathOfGeneratedTodo path to generated todo list for interactive rebase
+ * @param lastRetainedCommitRef the commit before the earliest commit to be
+ * changed during the interactive rebase or null if commit is root (first commit
+ * in history) of branch
+ */
+export declare function rebaseInteractive(repository: Repository, pathOfGeneratedTodo: string, lastRetainedCommitRef: string | null, opts?: RebaseInteractiveOptions): Promise<RebaseResult>;