@lumpcode/core 0.0.16 → 0.1.1

package/dist/index.js

@@ -3403,6 +3403,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) {
@@ -3745,6 +3779,75 @@ async function collectStepsForContext(params) {
     return collectedSteps;
 }
 
+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);
+        });
+    });
+}
+async function runOptionalGitCommand(input) {
+    const { label, getCommand, cwd, logger } = input;
+    try {
+        const command = await getCommand();
+        if (command == null || command === '') {
+            return 'ok';
+        }
+        const result = await execAsync(command, { cwd });
+        logger.verbose(`${label} ${JSON.stringify(result)}`);
+        if (!result.success) {
+            logger.error(formatExecFailureMessage({ label, failure: result }));
+            return 'failed';
+        }
+        return 'ok';
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to run ${label}: ${message}`);
+        return 'failed';
+    }
+}
 async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, signal, }) {
     const logger = loggerInput ?? createConsoleLogger({});
     const contextNames = contextList.map(context => context.name);
@@ -3783,6 +3886,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})`
@@ -3795,127 +3902,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 {
@@ -3943,39 +4060,39 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                 ...injectedGitAndWorkspaceFnsInput,
                 context,
             };
-            const gitAddCommand = await execAsync(gitAddCommandFn(perContextInput), { cwd: workspacePath });
-            logger.verbose(`gitAddCommand ${JSON.stringify(gitAddCommand)}`);
-            if (!gitAddCommand.success) {
+            const addOutcome = await runOptionalGitCommand({
+                label: `git add for context ${context.name}`,
+                getCommand: () => gitAddCommandFn(perContextInput),
+                cwd: workspacePath,
+                logger,
+            });
+            if (addOutcome === 'failed') {
                 runFailure = {
                     success: false,
                     data: {
-                        message: `Failed to add the changes for context ${context.name}: ${gitAddCommand.data.message}`,
+                        message: `Failed to add the changes for context ${context.name}`,
                     },
                 };
                 break;
             }
             const commitMessage = gitCommitMessageFn({ context, lumpVariables, baseBranch });
-            const commitCommand = await execAsync(gitCommitCommandFn({
-                ...perContextInput,
-                commitMessage,
-            }), { cwd: workspacePath });
-            logger.verbose(`commitCommand ${JSON.stringify(commitCommand)}`);
-            if (!commitCommand.success) {
-                logger.error(formatExecFailureMessage({
-                    label: `git commit for context ${context.name}`,
-                    failure: commitCommand,
-                }));
-            }
+            await runOptionalGitCommand({
+                label: `git commit for context ${context.name}`,
+                getCommand: () => gitCommitCommandFn({
+                    ...perContextInput,
+                    commitMessage,
+                }),
+                cwd: workspacePath,
+                logger,
+            });
         }
         if (!runFailure) {
-            const pushCommand = await execAsync(gitPushCommandFn(injectedGitAndWorkspaceFnsInput), { cwd: workspacePath });
-            logger.verbose(`pushCommand ${JSON.stringify(pushCommand)}`);
-            if (!pushCommand.success) {
-                logger.error(formatExecFailureMessage({
-                    label: `git push on branch ${branchName}`,
-                    failure: pushCommand,
-                }));
-            }
+            await runOptionalGitCommand({
+                label: `git push on branch ${branchName}`,
+                getCommand: () => gitPushCommandFn(injectedGitAndWorkspaceFnsInput),
+                cwd: workspacePath,
+                logger,
+            });
         }
     }
     finally {
@@ -4091,25 +4208,41 @@ async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot, lo
     }
 }
 
+/**
+ * Refreshes remote-tracking refs for status / planning (one network fetch).
+ * Uses `--no-write-fetch-head` so concurrent preflight/pull paths are safer.
+ */
+const refreshRemoteTrackingRefs = async (input) => {
+    const { projectRoot, remoteName = 'origin' } = input;
+    const result = await execAsync(`git fetch --prune --no-write-fetch-head ${remoteName}`, { cwd: projectRoot });
+    if (!result.success) {
+        return failure(result.data.message);
+    }
+    return success(undefined);
+};
+
 async function getContextStatus(params) {
-    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables: lumpVariablesInput, contextVariables = {}, remoteName = "origin", logger, } = params;
+    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables: lumpVariablesInput, contextVariables = {}, remoteName = "origin", logger, skipFetch = false, } = params;
     const lumpVariables = (lumpVariablesInput ?? {});
     const commitMessage = gitCommitMessageFn({
         context: { name: contextName, variables: contextVariables },
         lumpVariables,
         baseBranch,
     });
-    const fetchAll = await execAsync(`git fetch --all --prune`, { cwd: projectRoot });
-    if (!fetchAll.success)
-        return 'toDo';
-    const logResult = await execAsync(`git log --remotes=${remoteName} -F --grep=${shellSingleQuote(commitMessage)} --format=${shellSingleQuote('%H %s')}`, { cwd: projectRoot });
+    if (!skipFetch) {
+        const fetchResult = await refreshRemoteTrackingRefs({ projectRoot, remoteName });
+        if (!fetchResult.success)
+            return 'toDo';
+    }
+    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}`);
     logger?.verbose(`baseBranch ${baseBranch}`);
     logger?.verbose(`commitMessage ${commitMessage}`);
@@ -4164,7 +4297,7 @@ function validateContextListNames(contextList) {
 }
 
 async function getToDoContextList(params) {
-    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch, logger } = params;
+    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch, logger, refreshRemoteTrackingRefsFn = refreshRemoteTrackingRefs, } = params;
     const codeBasePathsResult = await getCodeBasePaths({ cwd: projectRoot, logger });
     if (!codeBasePathsResult.success) {
         return failure({
@@ -4182,21 +4315,28 @@ async function getToDoContextList(params) {
     const allCtxNames = contextList.flatMap(context => [context.name, ...(context.options?.dependsOnContexts ?? [])]);
     const allCtxNamesSet = new Set(allCtxNames);
     const allCtxNamesList = Array.from(allCtxNamesSet);
-    const contextStatusList = await Promise.all(allCtxNamesList.map((contextName) => {
-        return getContextStatus({
-            contextName: contextName,
+    const refreshResult = await refreshRemoteTrackingRefsFn({ projectRoot });
+    let contextStatusMap;
+    if (!refreshResult.success) {
+        logger?.warn(`Failed to refresh remote-tracking refs for context status; treating contexts as toDo: ${refreshResult.data}`);
+        contextStatusMap = new Map(allCtxNamesList.map((name) => [name, 'toDo']));
+    }
+    else {
+        const contextStatusList = await Promise.all(allCtxNamesList.map((contextName) => getContextStatus({
+            contextName,
             contextVariables: {}, // TODO: Remove contextVariables from getContextStatus, really not needed
             gitCommitMessageFn,
             lumpVariables,
             projectRoot,
             baseBranch,
             logger,
-        });
-    }));
-    const contextStatusMap = new Map(allCtxNamesList.map((contextName, i) => [contextName, contextStatusList[i]]));
+            skipFetch: true,
+        })));
+        contextStatusMap = new Map(allCtxNamesList.map((contextName, i) => [contextName, contextStatusList[i]]));
+    }
     const contextListToDo = contextList
-        .filter((context, contextIndex) => {
-        const contextStatus = contextStatusList[contextIndex];
+        .filter((context) => {
+        const contextStatus = contextStatusMap.get(context.name);
         if (contextStatus && contextStatus !== 'toDo')
             return false;
         const deps = context.options?.dependsOnContexts;
@@ -4262,7 +4402,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, } = 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 lumpVariables = (lumpVariablesInput ?? {});
     const logger = loggerInput ?? createConsoleLogger({});
     const contextListToDoResult = await getToDoContextList({
@@ -4272,6 +4412,7 @@ async function runLump(input) {
         baseBranch,
         gitCommitMessageFn,
         logger,
+        refreshRemoteTrackingRefsFn,
     });
     if (!contextListToDoResult.success) {
         return set(contextListToDoResult, ['data', 'message'], "Error in runLump: Failed to get to do context list. Original Error: " + contextListToDoResult.data.message);
@@ -4318,5 +4459,5 @@ async function runLump(input) {
     });
 }
 
-export { appendHistoryEntry, collectStepsForContext, contextStatus, createConsoleLogger, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, formatExecFailureMessage, getCodeBasePaths, getContextStatus, getToDoContextList, historyFormatFromPath, isProcessAlive, killProcessTree, nodeErrnoCode, parseGitLogHashSubjectLines, pathExists, readHistoryFile, resolveSpawnExecutable, runLump, set, shellSingleQuote, success, validateContextListNames, windowsNpmCmdShimBody, writeHistoryFile };
+export { GIT_LOG_HASH_BODY_FORMAT, appendHistoryEntry, collectStepsForContext, commitMessageIncludesMarker, contextStatus, createConsoleLogger, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, formatExecFailureMessage, getCodeBasePaths, getContextStatus, getToDoContextList, historyFormatFromPath, isProcessAlive, killProcessTree, nodeErrnoCode, parseGitLogHashBodyRecords, parseGitLogHashSubjectLines, pathExists, readHistoryFile, refreshRemoteTrackingRefs, resolveSpawnExecutable, runLump, set, shellSingleQuote, success, validateContextListNames, windowsNpmCmdShimBody, writeHistoryFile };
 //# sourceMappingURL=index.js.map