@lumpcode/core 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -3424,6 +3424,40 @@ function parseGitLogHashSubjectLines(stdout) {
     });
 }
 
+const GIT_LOG_HASH_BODY_FORMAT = '%x1e%H%x00%B';
+const RECORD_SEPARATOR = '\x1e';
+const HASH_MESSAGE_SEPARATOR = '\x00';
+/** Parses `git log --format='%x1e%H%x00%B'` stdout into commit hash and full-message pairs. */
+function parseGitLogHashBodyRecords(stdout) {
+    const records = [];
+    for (const record of stdout.split(RECORD_SEPARATOR)) {
+        if (!record)
+            continue;
+        const nul = record.indexOf(HASH_MESSAGE_SEPARATOR);
+        if (nul === -1)
+            continue;
+        const hash = record.slice(0, nul).trim();
+        if (!hash)
+            continue;
+        records.push({
+            hash,
+            message: record.slice(nul + 1),
+        });
+    }
+    return records;
+}
+
+const MARKER_CONTINUE = '[A-Za-z0-9_-]';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** True when `marker` occurs in `message` and is not a prefix of a longer `[A-Za-z0-9_-]*` token. */
+function commitMessageIncludesMarker(message, marker) {
+    if (marker.length === 0)
+        return false;
+    return new RegExp(`${escapeRegExp(marker)}(?!${MARKER_CONTINUE})`).test(message);
+}
+
 /** Node-style `code` from a caught unknown error (e.g. `ENOENT`), or undefined. */
 function nodeErrnoCode(error) {
     if (error && typeof error === 'object' && 'code' in error) {
@@ -3571,32 +3605,54 @@ async function killProcessTree(input) {
 }
 
 const execAsyncBase = node_util.promisify(node_child_process.exec);
+/** Same signal Node's `exec` `timeout` option uses by default. */
+const EXEC_TIMEOUT_KILL_SIGNAL = 'SIGTERM';
+function isExecTimeout(error, timeoutMillis) {
+    if (timeoutMillis === undefined) {
+        return false;
+    }
+    if (typeof error !== 'object' || error === null) {
+        return false;
+    }
+    const execError = error;
+    if (execError.killed !== true) {
+        return false;
+    }
+    // Windows has no POSIX signals; Node force-kills and `signal` is often null.
+    if (process.platform === 'win32') {
+        return true;
+    }
+    return execError.signal === EXEC_TIMEOUT_KILL_SIGNAL;
+}
 async function execAsync(command, options) {
-    const { stdout, stderr, hasErrored } = await execAsyncBase(command, { cwd: options?.cwd })
-        .then(result => ({
-        stdout: result.stdout,
-        stderr: result.stderr,
-        hasErrored: false,
-    }))
-        .catch(e => ({
-        stderr: e,
-        stdout: e,
-        hasErrored: true,
-    }));
-    if (hasErrored) {
+    const timeoutMillis = options?.timeoutMillis;
+    try {
+        const result = await execAsyncBase(command, {
+            cwd: options?.cwd,
+            ...(timeoutMillis !== undefined
+                ? { timeout: timeoutMillis, killSignal: EXEC_TIMEOUT_KILL_SIGNAL }
+                : {}),
+        });
+        return success({
+            stdout: String(result.stdout),
+            stderr: String(result.stderr),
+        });
+    }
+    catch (e) {
+        const timedOut = isExecTimeout(e, timeoutMillis);
+        const reason = timedOut ? 'timeout' : 'exit';
         return failure({
-            message: `Command ${command} failed with error: ${stderr}`,
+            message: timedOut
+                ? `Command ${command} timed out after ${timeoutMillis}ms`
+                : `Command ${command} failed with error: ${e}`,
+            reason,
             info: {
                 command,
-                stdout,
-                stderr,
+                stdout: e,
+                stderr: e,
             },
         });
     }
-    return success({
-        stdout,
-        stderr,
-    });
 }
 
 function execBinary(input) {
@@ -3766,28 +3822,85 @@ async function collectStepsForContext(params) {
     return collectedSteps;
 }
 
-async function runOptionalGitCommand(input) {
-    const { label, getCommand, cwd, logger } = input;
+const ABORT_STEP_WALK_MESSAGE = 'Process aborted';
+function stepWalkAbortedFailure() {
+    return {
+        success: false,
+        data: {
+            message: ABORT_STEP_WALK_MESSAGE,
+            reason: 'stepWalkFailed',
+        },
+    };
+}
+function createStepWalkAbortError() {
+    const error = new Error(ABORT_STEP_WALK_MESSAGE);
+    error.name = 'AbortError';
+    return error;
+}
+function isStepWalkAbortError(error) {
+    return (typeof error === 'object'
+        && error !== null
+        && 'name' in error
+        && error.name === 'AbortError');
+}
+/**
+ * Await user-hook work, but stop waiting once `signal` aborts so the walk can
+ * unwind (locks/teardown). Does not cancel sync busy-loops on the event loop.
+ */
+async function awaitUnlessAborted(work, signal) {
+    if (!signal) {
+        return await work;
+    }
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            cleanup();
+            reject(createStepWalkAbortError());
+        };
+        const cleanup = () => {
+            signal.removeEventListener('abort', onAbort);
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        Promise.resolve(work).then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+/**
+ * Result-aware runner for `gitAddCommitFn` / `gitPushFn`.
+ * nullish Success → no-op; empty string / Failure / throw / exec fail → failed.
+ */
+async function runGitResultHook(input) {
+    const { getResult, cwd, logger, execLabel } = input;
     try {
-        const command = await getCommand();
-        if (command == null || command === '') {
-            return 'ok';
-        }
-        const result = await execAsync(command, { cwd });
-        logger.verbose(`${label} ${JSON.stringify(result)}`);
+        const result = await getResult();
         if (!result.success) {
-            logger.error(formatExecFailureMessage({ label, failure: result }));
-            return 'failed';
+            return { status: 'failed', detail: result.data };
+        }
+        const command = result.data;
+        if (command == null) {
+            return { status: 'ok' };
+        }
+        if (command === '') {
+            return { status: 'failed', detail: 'empty command string' };
         }
-        return 'ok';
+        const execResult = await execAsync(command, { cwd });
+        logger.verbose(`${execLabel} ${JSON.stringify(execResult)}`);
+        if (!execResult.success) {
+            return { status: 'failed', detail: execResult.data.message };
+        }
+        return { status: 'ok' };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Failed to run ${label}: ${message}`);
-        return 'failed';
+        return { status: 'failed', detail: message };
     }
 }
-async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, signal, }) {
+async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommitFn, gitPushFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, signal, }) {
     const logger = loggerInput ?? createConsoleLogger({});
     const contextNames = contextList.map(context => context.name);
     logger.verbose(`contextNames ${JSON.stringify(contextNames)}`);
@@ -3813,7 +3926,9 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
         });
         logger.verbose(`setupWorkspaceCommandExec ${JSON.stringify(setupWorkspaceCommandExec)}`);
         if (!setupWorkspaceCommandExec.success) {
-            return set(setupWorkspaceCommandExec, ['data', 'message'], `Failed to setup the workspace: ${setupWorkspaceCommandExec.data.message}`);
+            return failure({
+                message: `Failed to setup the workspace: ${setupWorkspaceCommandExec.data.message}`,
+            });
         }
         if (afterExec) {
             await afterExec({ workspacePath });
@@ -3825,6 +3940,10 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
     let runFailure;
     try {
         for (let i = 0; i < contextList.length; i++) {
+            if (signal?.aborted) {
+                runFailure = stepWalkAbortedFailure();
+                break;
+            }
             const context = contextList[i];
             logger.info(contextList.length > 1
                 ? `Running context "${context.name}" (${i + 1}/${contextList.length})`
@@ -3837,127 +3956,137 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
             const contextRunState = setupResult?.contextRunState || {};
             let stepWalkFailure;
             async function walkAndExecuteSteps(stepsToExec, currStepIndex) {
-                for (let stepIndex = 0; stepIndex < stepsToExec.length; stepIndex++) {
-                    if (stepWalkFailure) {
-                        return;
-                    }
-                    const step = stepsToExec[stepIndex];
-                    const nextCallHeadIndex = [...currStepIndex, stepIndex];
-                    const compositeStepIndex = nextCallHeadIndex.length === 1 ? nextCallHeadIndex[0] : nextCallHeadIndex;
-                    if (typeof step === 'function' || Array.isArray(step)) {
-                        let subSteps = [];
-                        if (typeof step === 'function') {
-                            subSteps = await step({
+                try {
+                    for (let stepIndex = 0; stepIndex < stepsToExec.length; stepIndex++) {
+                        if (stepWalkFailure) {
+                            return;
+                        }
+                        signal?.throwIfAborted();
+                        const step = stepsToExec[stepIndex];
+                        const nextCallHeadIndex = [...currStepIndex, stepIndex];
+                        const compositeStepIndex = nextCallHeadIndex.length === 1 ? nextCallHeadIndex[0] : nextCallHeadIndex;
+                        if (typeof step === 'function' || Array.isArray(step)) {
+                            const subSteps = typeof step === 'function'
+                                ? await awaitUnlessAborted(step({
+                                    context,
+                                    stepIndex: compositeStepIndex,
+                                    contextRunState,
+                                    lumpVariables,
+                                }), signal)
+                                : step;
+                            await walkAndExecuteSteps(subSteps, nextCallHeadIndex);
+                            continue;
+                        }
+                        logger.verbose(`step ${JSON.stringify(step)}`);
+                        const { commandFn = () => null, stepVariables, promptFn, postCommandExecFn, continueOnError, timeoutMillis = 1000 * 60 * 30, } = step;
+                        const prompt = promptFn
+                            ? await awaitUnlessAborted(promptFn({
                                 context,
                                 stepIndex: compositeStepIndex,
                                 contextRunState,
                                 lumpVariables,
+                                stepVariables,
+                            }), signal)
+                            : '';
+                        const command = await awaitUnlessAborted(commandFn({
+                            context,
+                            prompt,
+                            stepIndex: compositeStepIndex,
+                            contextRunState,
+                            lumpVariables,
+                            stepVariables,
+                            projectRoot,
+                            workspacePath,
+                        }), signal);
+                        let commandResult = '';
+                        let commandSucceeded = true;
+                        if (command != null) {
+                            const { executable, args, env } = command;
+                            logger.verbose(`command for prompt ${executable} ${args.join(' ')}`);
+                            if (env != null) {
+                                logger.verbose(`command env overrides ${JSON.stringify(env)}`);
+                            }
+                            logger.verbose(`workspacePath ${workspacePath}`);
+                            const commandExec = await execBinary({
+                                binaryPath: executable,
+                                args,
+                                timeoutMillis,
+                                stdio: ['inherit', 'pipe', 'pipe'],
+                                cwd: workspacePath,
+                                signal,
+                                ...(env != null ? { env: { ...process.env, ...env } } : {}),
                             });
+                            logger.verbose(`commandExec ${JSON.stringify(commandExec)}`);
+                            if (!commandExec.success) {
+                                const aborted = commandExec.data.reason === 'aborted';
+                                if (aborted || !continueOnError) {
+                                    stepWalkFailure = {
+                                        success: false,
+                                        data: {
+                                            message: `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`,
+                                            reason: 'stepWalkFailed',
+                                        },
+                                    };
+                                    return;
+                                }
+                                commandSucceeded = false;
+                                commandResult = (commandExec.data.stdout
+                                    || commandExec.data.stderr
+                                    || commandExec.data.message
+                                    || '').toString();
+                                logger.verbose(`commandResult ${commandResult}`);
+                            }
+                            else {
+                                commandResult = (commandExec.data.stdout || commandExec.data.stderr || '').toString();
+                                logger.verbose(`commandResult ${commandResult}`);
+                            }
+                            if (commandSucceeded) {
+                                const gitStatusAfterCommand = await execAsync(`git status`, { cwd: workspacePath });
+                                logger.verbose(`gitStatusCommand ${JSON.stringify(gitStatusAfterCommand.data)}`);
+                            }
                         }
-                        else {
-                            subSteps = step;
-                        }
-                        await walkAndExecuteSteps(subSteps, nextCallHeadIndex);
-                        continue;
-                    }
-                    logger.verbose(`step ${JSON.stringify(step)}`);
-                    const { commandFn = () => null, stepVariables, promptFn, postCommandExecFn, continueOnError, timeoutMillis = 1000 * 60 * 30, } = step;
-                    const prompt = promptFn
-                        ? await promptFn({
+                        const historyEntry = {
+                            commandResult,
+                            commandSucceeded,
                             context,
+                            prompt,
                             stepIndex: compositeStepIndex,
                             contextRunState,
                             lumpVariables,
                             stepVariables,
-                        })
-                        : '';
-                    const command = await commandFn({
-                        context,
-                        prompt,
-                        stepIndex: compositeStepIndex,
-                        contextRunState,
-                        lumpVariables,
-                        stepVariables,
-                        projectRoot,
-                        workspacePath,
-                    });
-                    let commandResult = '';
-                    let commandSucceeded = true;
-                    if (command != null) {
-                        const { executable, args, env } = command;
-                        logger.verbose(`command for prompt ${executable} ${args.join(' ')}`);
-                        if (env != null) {
-                            logger.verbose(`command env overrides ${JSON.stringify(env)}`);
-                        }
-                        logger.verbose(`workspacePath ${workspacePath}`);
-                        const commandExec = await execBinary({
-                            binaryPath: executable,
-                            args,
-                            timeoutMillis,
-                            stdio: ['inherit', 'pipe', 'pipe'],
-                            cwd: workspacePath,
+                            projectRoot,
+                        };
+                        const postCommandExecFnInput = {
+                            ...historyEntry,
                             signal,
-                            ...(env != null ? { env: { ...process.env, ...env } } : {}),
-                        });
-                        logger.verbose(`commandExec ${JSON.stringify(commandExec)}`);
-                        if (!commandExec.success) {
-                            const aborted = commandExec.data.reason === 'aborted';
-                            if (aborted || !continueOnError) {
-                                stepWalkFailure = {
-                                    success: false,
-                                    data: {
-                                        message: `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`,
-                                        reason: 'stepWalkFailed',
-                                    },
-                                };
-                                return;
+                        };
+                        logger.verbose(`context is ${JSON.stringify(context)}`);
+                        const keepHistoryFilePath = getKeepHistoryFilePathFn(context) || '';
+                        logger.verbose(`keepHistoryFilePath ${keepHistoryFilePath}`);
+                        if (!!command && keepHistoryFilePath.length > 0) {
+                            const appendResult = await appendHistoryEntry({
+                                filePath: keepHistoryFilePath,
+                                entry: historyEntry,
+                            });
+                            if (!appendResult.success) {
+                                // TODO: sanitize history appending to avoid this warning for certain commands outputs
+                                logger.warn(`Failed to append history entry to ${keepHistoryFilePath}: ${appendResult.data}`);
                             }
-                            commandSucceeded = false;
-                            commandResult = (commandExec.data.stdout
-                                || commandExec.data.stderr
-                                || commandExec.data.message
-                                || '').toString();
-                            logger.verbose(`commandResult ${commandResult}`);
-                        }
-                        else {
-                            commandResult = (commandExec.data.stdout || commandExec.data.stderr || '').toString();
-                            logger.verbose(`commandResult ${commandResult}`);
-                        }
-                        if (commandSucceeded) {
-                            const gitStatusAfterCommand = await execAsync(`git status`, { cwd: workspacePath });
-                            logger.verbose(`gitStatusCommand ${JSON.stringify(gitStatusAfterCommand.data)}`);
                         }
-                    }
-                    const postCommandExecFnInput = {
-                        commandResult,
-                        commandSucceeded,
-                        context,
-                        prompt,
-                        stepIndex: compositeStepIndex,
-                        contextRunState,
-                        lumpVariables,
-                        stepVariables,
-                        projectRoot,
-                    };
-                    logger.verbose(`context is ${JSON.stringify(context)}`);
-                    const keepHistoryFilePath = getKeepHistoryFilePathFn(context) || '';
-                    logger.verbose(`keepHistoryFilePath ${keepHistoryFilePath}`);
-                    if (!!command && keepHistoryFilePath.length > 0) {
-                        const appendResult = await appendHistoryEntry({
-                            filePath: keepHistoryFilePath,
-                            entry: postCommandExecFnInput,
-                        });
-                        if (!appendResult.success) {
-                            // TODO: sanitize history appending to avoid this warning for certain commands outputs
-                            logger.warn(`Failed to append history entry to ${keepHistoryFilePath}: ${appendResult.data}`);
+                        if (postCommandExecFn) {
+                            const returnedSteps = await awaitUnlessAborted(postCommandExecFn(postCommandExecFnInput), signal);
+                            if (returnedSteps != null && returnedSteps.length > 0) {
+                                await walkAndExecuteSteps(returnedSteps, nextCallHeadIndex);
+                            }
                         }
                     }
-                    if (postCommandExecFn) {
-                        const returnedSteps = await postCommandExecFn(postCommandExecFnInput);
-                        if (returnedSteps != null && returnedSteps.length > 0) {
-                            await walkAndExecuteSteps(returnedSteps, nextCallHeadIndex);
-                        }
+                }
+                catch (error) {
+                    if (isStepWalkAbortError(error)) {
+                        stepWalkFailure = stepWalkAbortedFailure();
+                        return;
                     }
+                    throw error;
                 }
             }
             try {
@@ -3981,43 +4110,42 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                 runFailure = stepWalkFailure;
                 break;
             }
-            const perContextInput = {
-                ...injectedGitAndWorkspaceFnsInput,
-                context,
-            };
-            const addOutcome = await runOptionalGitCommand({
-                label: `git add for context ${context.name}`,
-                getCommand: () => gitAddCommandFn(perContextInput),
+            const commitMessage = gitCommitMessageFn({ context, lumpVariables, baseBranch });
+            const addCommitExecLabel = `git add+commit for context ${context.name}`;
+            const addCommitOutcome = await runGitResultHook({
+                getResult: () => gitAddCommitFn({
+                    ...injectedGitAndWorkspaceFnsInput,
+                    context,
+                    commitMessage,
+                }),
                 cwd: workspacePath,
                 logger,
+                execLabel: addCommitExecLabel,
             });
-            if (addOutcome === 'failed') {
+            if (addCommitOutcome.status === 'failed') {
+                const message = `Failed to add and commit for context ${context.name}: ${addCommitOutcome.detail}`;
+                logger.error(message);
                 runFailure = {
                     success: false,
                     data: {
-                        message: `Failed to add the changes for context ${context.name}`,
+                        message,
+                        reason: 'gitAddCommitFailed',
                     },
                 };
                 break;
             }
-            const commitMessage = gitCommitMessageFn({ context, lumpVariables, baseBranch });
-            await runOptionalGitCommand({
-                label: `git commit for context ${context.name}`,
-                getCommand: () => gitCommitCommandFn({
-                    ...perContextInput,
-                    commitMessage,
-                }),
-                cwd: workspacePath,
-                logger,
-            });
         }
         if (!runFailure) {
-            await runOptionalGitCommand({
-                label: `git push on branch ${branchName}`,
-                getCommand: () => gitPushCommandFn(injectedGitAndWorkspaceFnsInput),
+            const pushExecLabel = `git push on branch ${branchName}`;
+            const pushOutcome = await runGitResultHook({
+                getResult: () => gitPushFn(injectedGitAndWorkspaceFnsInput),
                 cwd: workspacePath,
                 logger,
+                execLabel: pushExecLabel,
             });
+            if (pushOutcome.status === 'failed') {
+                logger.error(`Failed to ${pushExecLabel}: ${pushOutcome.detail}`);
+            }
         }
     }
     finally {
@@ -4159,13 +4287,13 @@ async function getContextStatus(params) {
         if (!fetchResult.success)
             return 'toDo';
     }
-    const logResult = await execAsync(`git log --remotes=${remoteName} -F --grep=${shellSingleQuote(commitMessage)} --format=${shellSingleQuote('%H %s')}`, { cwd: projectRoot });
+    const logResult = await execAsync(`git log --remotes=${remoteName} -F --grep=${shellSingleQuote(commitMessage)} --format=${shellSingleQuote(GIT_LOG_HASH_BODY_FORMAT)}`, { cwd: projectRoot });
     if (!logResult.success)
         return 'toDo';
     logger?.verbose(`logResult ${JSON.stringify(logResult.data)}`);
     const logResultOutput = logResult.data.stdout || logResult.data.stderr || '';
-    const matchingHashes = parseGitLogHashSubjectLines(logResultOutput)
-        .filter((entry) => entry.subject === commitMessage)
+    const matchingHashes = parseGitLogHashBodyRecords(logResultOutput)
+        .filter((entry) => commitMessageIncludesMarker(entry.message, commitMessage))
         .map((entry) => entry.hash);
     logger?.verbose(`contextName ${contextName}`);
     logger?.verbose(`remoteName ${remoteName}`);
@@ -4282,14 +4410,11 @@ const contextStatus = ['toDo', 'branchPushed', 'finished'];
 const defaultGitCommitMessageFn = ({ context }) => {
     return `LUMP:${context.name}`;
 };
-const defaultGitPushCommandFn = (input) => {
-    return `git push origin ${shellSingleQuote(input.branchName)}`;
-};
-const defaultGitAddCommandFn = () => {
-    return `git add .`;
+const defaultGitAddCommitFn = (input) => {
+    return success(`git add . && git commit --allow-empty -m ${shellSingleQuote(input.commitMessage)}`);
 };
-const defaultGitCommitCommandFn = (input) => {
-    return `git commit --allow-empty -m ${shellSingleQuote(input.commitMessage)}`;
+const defaultGitPushFn = (input) => {
+    return success(`git push origin ${shellSingleQuote(input.branchName)}`);
 };
 const defaultSetupWorkspaceFn = async (input) => {
     const { baseBranch, branchName } = input;
@@ -4327,7 +4452,7 @@ const defaultSetupWorkspaceFnWithWorktree = async (input) => {
 };
 
 async function runLump(input) {
-    const { baseBranch, branchFn, lumpVariables: lumpVariablesInput, getContextListFn, gitAddCommandFn = defaultGitAddCommandFn, gitCommitCommandFn = defaultGitCommitCommandFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushCommandFn = defaultGitPushCommandFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, getKeepHistoryFilePathFn = () => undefined, logger: loggerInput, signal, refreshRemoteTrackingRefsFn, } = input;
+    const { baseBranch, branchFn, lumpVariables: lumpVariablesInput, getContextListFn, gitAddCommitFn = defaultGitAddCommitFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushFn = defaultGitPushFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, getKeepHistoryFilePathFn = () => undefined, logger: loggerInput, signal, refreshRemoteTrackingRefsFn, } = input;
     const lumpVariables = (lumpVariablesInput ?? {});
     const logger = loggerInput ?? createConsoleLogger({});
     const contextListToDoResult = await getToDoContextList({
@@ -4362,10 +4487,9 @@ async function runLump(input) {
         branchFn: branchFn,
         lumpVariables: lumpVariables,
         contextList: nextContextsForBranchList,
-        gitAddCommandFn,
-        gitCommitCommandFn,
+        gitAddCommitFn,
         gitCommitMessageFn,
-        gitPushCommandFn,
+        gitPushFn,
         projectRoot,
         steps,
         setupFn,
@@ -4384,14 +4508,15 @@ async function runLump(input) {
     });
 }
 
+exports.GIT_LOG_HASH_BODY_FORMAT = GIT_LOG_HASH_BODY_FORMAT;
 exports.appendHistoryEntry = appendHistoryEntry;
 exports.collectStepsForContext = collectStepsForContext;
+exports.commitMessageIncludesMarker = commitMessageIncludesMarker;
 exports.contextStatus = contextStatus;
 exports.createConsoleLogger = createConsoleLogger;
-exports.defaultGitAddCommandFn = defaultGitAddCommandFn;
-exports.defaultGitCommitCommandFn = defaultGitCommitCommandFn;
+exports.defaultGitAddCommitFn = defaultGitAddCommitFn;
 exports.defaultGitCommitMessageFn = defaultGitCommitMessageFn;
-exports.defaultGitPushCommandFn = defaultGitPushCommandFn;
+exports.defaultGitPushFn = defaultGitPushFn;
 exports.defaultSetupWorkspaceFn = defaultSetupWorkspaceFn;
 exports.defaultSetupWorkspaceFnWithWorktree = defaultSetupWorkspaceFnWithWorktree;
 exports.defaultTeardownWorkspaceFn = defaultTeardownWorkspaceFn;
@@ -4408,6 +4533,7 @@ exports.historyFormatFromPath = historyFormatFromPath;
 exports.isProcessAlive = isProcessAlive;
 exports.killProcessTree = killProcessTree;
 exports.nodeErrnoCode = nodeErrnoCode;
+exports.parseGitLogHashBodyRecords = parseGitLogHashBodyRecords;
 exports.parseGitLogHashSubjectLines = parseGitLogHashSubjectLines;
 exports.pathExists = pathExists;
 exports.readHistoryFile = readHistoryFile;