@lumpcode/core 0.0.0

package/dist/index.js

@@ -0,0 +1,723 @@
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs$1 from 'fs/promises';
+import { dirname } from 'path';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import ignore from 'ignore';
+import z from 'zod';
+
+function set(object, path, value) {
+    const keys = Array.isArray(path) ? path : [path];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let current = object;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!(key in current)) {
+            current[key] = typeof keys[i + 1] === "number" ? [] : {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+    return object;
+}
+
+function success(data) {
+    return {
+        success: true,
+        data,
+    };
+}
+
+function failure(data) {
+    return {
+        success: false,
+        data,
+    };
+}
+
+function decision(possibilities, defaultValue) {
+    for (const [condition, result] of possibilities) {
+        if (condition()) {
+            return result();
+        }
+    }
+    if (defaultValue) {
+        return defaultValue;
+    }
+    throw new Error('No value found in decision');
+}
+
+/**
+ * Wrap an arbitrary string in quotes so it can be safely embedded in
+ * a shell command (e.g. the command string passed to `execAsync`).
+ *
+ * On Unix uses single quotes (no expansion). On Windows uses cmd.exe
+ * double-quote rules (`""` for a literal `"`).
+ */
+function shellSingleQuote(value) {
+    if (process.platform === 'win32') {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return `'${value.split("'").join(`'\\''`)}'`;
+}
+
+/**
+ * Wrap a shell fragment so failure does not break a surrounding `&&` chain.
+ *
+ * Unix: `cmd || true`. Windows cmd.exe: `(cmd || cd .)`.
+ */
+function shellBestEffort(command) {
+    if (process.platform === 'win32') {
+        return `(${command} || cd .)`;
+    }
+    return `${command} || true`;
+}
+
+const execAsyncBase = promisify(exec);
+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) {
+        return failure({
+            message: `Command ${command} failed with error: ${stderr}`,
+            info: {
+                command,
+                stdout,
+                stderr,
+            },
+        });
+    }
+    return success({
+        stdout,
+        stderr,
+    });
+}
+
+function execBinary(binaryPath, args, timeoutMillis = 1000 * 60 * 10, options) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve(result);
+        };
+        const timeout = setTimeout(() => {
+            finish(failure({
+                message: `Process timed out after ${timeoutMillis} milliseconds`,
+                binaryPath,
+                args,
+            }));
+        }, timeoutMillis);
+        const child = spawn(binaryPath, args, options || {});
+        let stdout = '', stderr = '';
+        child.stdout?.on('data', (data) => { stdout += data; });
+        child.stderr?.on('data', (data) => { stderr += data; });
+        child.on('error', (err) => {
+            finish(failure({
+                message: err.message,
+                binaryPath,
+                args,
+                stdout,
+                stderr,
+            }));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                finish(success({ stdout, stderr }));
+                return;
+            }
+            finish(failure({
+                message: `Process exited with code ${code}: ${stderr}`,
+                binaryPath,
+                args,
+                code: code ?? undefined,
+                stdout,
+                stderr,
+            }));
+        });
+    });
+}
+
+async function collectStepsForContext(params) {
+    const { context, contextList, currentContextIndex, lumpVariables, steps: stepsToCollect, setupFn, projectRoot, workspacePath, } = params;
+    const setupResult = await setupFn({
+        contextList,
+        lumpVariables,
+        currentContextIndex,
+    });
+    const contextRunState = setupResult?.contextRunState ?? {};
+    const collectedSteps = [];
+    async function walk(stepsToExec, currStepIndex) {
+        for (let stepIndex = 0; stepIndex < stepsToExec.length; stepIndex++) {
+            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({
+                        context,
+                        stepIndex: compositeStepIndex,
+                        contextRunState,
+                        lumpVariables,
+                    });
+                }
+                else {
+                    subSteps = step;
+                }
+                await walk(subSteps, nextCallHeadIndex);
+                continue;
+            }
+            const { commandFn, stepVariables, promptFn, postCommandExecFn, timeoutMillis, } = step;
+            const prompt = promptFn
+                ? await promptFn({
+                    context,
+                    stepIndex: compositeStepIndex,
+                    contextRunState,
+                    lumpVariables,
+                    stepVariables,
+                })
+                : '';
+            const command = await commandFn({
+                context,
+                prompt,
+                stepIndex: compositeStepIndex,
+                contextRunState,
+                lumpVariables,
+                stepVariables,
+                projectRoot,
+                workspacePath,
+            });
+            collectedSteps.push({
+                stepIndex: compositeStepIndex,
+                ...(prompt.length > 0 && { prompt }),
+                command: command != null
+                    ? { executable: command.executable, args: command.args }
+                    : null,
+                postCommandExecFn,
+                stepVariables,
+                timeoutMillis,
+            });
+        }
+    }
+    await walk(stepsToCollect, []);
+    return collectedSteps;
+}
+
+async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, verbose, }) {
+    const contextNames = contextList.map(context => context.name);
+    log('contextNames', contextNames);
+    const contextRunStateList = [];
+    const branchName = await branchFn({
+        contextList,
+        contextRunStateList,
+        lumpVariables,
+    });
+    log('branchName', branchName);
+    const injectedGitAndWorkspaceFnsInput = {
+        baseBranch,
+        branchName,
+        contextList,
+        workspacePath: '.',
+    };
+    const { command: setupWorkspaceCommand, workspacePath } = await setupWorkspaceFn(injectedGitAndWorkspaceFnsInput);
+    log('setupWorkspaceCommand', setupWorkspaceCommand);
+    log('workspacePath', workspacePath);
+    if (setupWorkspaceCommand) {
+        const setupWorkspaceCommandExec = await execAsync(setupWorkspaceCommand, {
+            cwd: projectRoot,
+        });
+        log('setupWorkspaceCommandExec', setupWorkspaceCommandExec);
+        if (!setupWorkspaceCommandExec.success) {
+            return set(setupWorkspaceCommandExec, ['data', 'message'], `Failed to setup the workspace: ${setupWorkspaceCommandExec.data.message}`);
+        }
+    }
+    const gitStatusCommand = await execAsync(`git status`, { cwd: workspacePath });
+    log('gitStatusCommand', gitStatusCommand.data);
+    injectedGitAndWorkspaceFnsInput.workspacePath = workspacePath;
+    for (let i = 0; i < contextList.length; i++) {
+        const context = contextList[i];
+        const setupResult = await setupFn({
+            contextList,
+            lumpVariables,
+            currentContextIndex: i,
+        });
+        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({
+                            context,
+                            stepIndex: compositeStepIndex,
+                            contextRunState,
+                            lumpVariables,
+                        });
+                    }
+                    else {
+                        subSteps = step;
+                    }
+                    await walkAndExecuteSteps(subSteps, nextCallHeadIndex);
+                    continue;
+                }
+                log('step', step);
+                const { commandFn, stepVariables, promptFn, postCommandExecFn, timeoutMillis = 1000 * 60 * 30, } = step;
+                const prompt = promptFn
+                    ? await promptFn({
+                        context,
+                        stepIndex: compositeStepIndex,
+                        contextRunState,
+                        lumpVariables,
+                        stepVariables,
+                    })
+                    : '';
+                const command = await commandFn({
+                    context,
+                    prompt,
+                    stepIndex: compositeStepIndex,
+                    contextRunState,
+                    lumpVariables,
+                    stepVariables,
+                    projectRoot,
+                    workspacePath,
+                });
+                let commandResult = '';
+                if (command != null) {
+                    const { executable, args } = command;
+                    log('command for prompt', executable, args);
+                    log('workspacePath', workspacePath);
+                    const commandExec = await execBinary(executable, args, timeoutMillis, {
+                        stdio: ['inherit', 'pipe', 'pipe'],
+                        cwd: workspacePath,
+                    });
+                    log('commandExec', commandExec);
+                    if (!commandExec.success) {
+                        stepWalkFailure = set(commandExec, ['data', 'message'], `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`);
+                        return;
+                    }
+                    commandResult = (commandExec.data.stdout || commandExec.data.stderr || '').toString();
+                    log('commandResult', commandResult);
+                    const gitStatusCommand = await execAsync(`git status`, { cwd: workspacePath });
+                    log('gitStatusCommand', gitStatusCommand.data);
+                }
+                const postCommandExecFnInput = {
+                    commandResult,
+                    context,
+                    prompt,
+                    stepIndex: compositeStepIndex,
+                    contextRunState,
+                    lumpVariables,
+                    stepVariables,
+                    projectRoot,
+                };
+                log('context is', context);
+                const keepHistoryFilePath = getKeepHistoryFilePathFn(context) || '';
+                log('keepHistoryFilePath', keepHistoryFilePath);
+                if (!!command && keepHistoryFilePath.length > 0) {
+                    const makeHistoryFileIfNotExists = async () => {
+                        if (await fs$1.stat(keepHistoryFilePath).then(() => true).catch(() => false))
+                            return;
+                        await fs$1.mkdir(dirname(keepHistoryFilePath), { recursive: true });
+                        await fs$1.writeFile(keepHistoryFilePath, "[]", 'utf-8');
+                    };
+                    await makeHistoryFileIfNotExists();
+                    const historyFileContent = await fs$1.readFile(keepHistoryFilePath, 'utf-8');
+                    log('historyFileContent', historyFileContent);
+                    const history = JSON.parse(historyFileContent);
+                    log('history', history);
+                    history.push({
+                        ...postCommandExecFnInput,
+                    });
+                    log('history after push', history);
+                    await fs$1.writeFile(keepHistoryFilePath, JSON.stringify(history, null, 2), 'utf-8');
+                }
+                if (postCommandExecFn) {
+                    await postCommandExecFn(postCommandExecFnInput);
+                }
+            }
+        }
+        await walkAndExecuteSteps(steps, []);
+        if (stepWalkFailure) {
+            return stepWalkFailure;
+        }
+        await teardownFn({
+            lumpVariables,
+            contextList,
+            currentContextIndex: i,
+            contextRunState,
+        });
+        const perContextInput = {
+            ...injectedGitAndWorkspaceFnsInput,
+            context,
+        };
+        const gitAddCommand = await execAsync(gitAddCommandFn(perContextInput), { cwd: workspacePath });
+        log('gitAddCommand', gitAddCommand);
+        if (!gitAddCommand.success) {
+            return set(gitAddCommand, ['data', 'message'], `Failed to add the changes for context ${context.name}: ${gitAddCommand.data.message}`);
+        }
+        const commitMessage = gitCommitMessageFn({ context, lumpVariables, baseBranch });
+        const commitCommand = await execAsync(gitCommitCommandFn({
+            ...perContextInput,
+            commitMessage,
+        }), { cwd: workspacePath });
+        log('commitCommand', commitCommand);
+        if (!commitCommand.success) {
+            log(`Failed to commit the changes for context ${context.name}:`, commitCommand.data);
+        }
+    }
+    const pushCommand = await execAsync(gitPushCommandFn(injectedGitAndWorkspaceFnsInput), { cwd: workspacePath });
+    log('pushCommand', pushCommand);
+    if (!pushCommand.success) {
+        log(`Failed to push the changes on branch ${branchName}: ${pushCommand.data.message}`);
+    }
+    const teardownWorkspaceCommand = await teardownWorkspaceFn(injectedGitAndWorkspaceFnsInput);
+    console.log('teardownWorkspaceCommand', teardownWorkspaceCommand);
+    if (teardownWorkspaceCommand) {
+        const teardownWorkspaceCommandExec = await execAsync(teardownWorkspaceCommand, { cwd: workspacePath });
+        console.log('teardownWorkspaceCommandExec', teardownWorkspaceCommandExec);
+        if (!teardownWorkspaceCommandExec.success) {
+            return set(teardownWorkspaceCommandExec, ['data', 'message'], `Failed to teardown the workspace: ${teardownWorkspaceCommandExec.data.message}`);
+        }
+    }
+    return success({
+        branchName,
+        contextNames,
+        contextRunStateList,
+    });
+    function log(...params) {
+        if (verbose) {
+            console.log(...params);
+        }
+    }
+}
+
+async function getCodeBasePaths({ cwd, }) {
+    const allPaths = [];
+    const gitignoresMap = await getGitignoresMap({ startDir: cwd, stopAtDir: cwd });
+    try {
+        await scanDirectory({
+            dirPath: cwd,
+            allPaths,
+            gitignoresMap,
+            projectRoot: cwd,
+        });
+    }
+    catch (error) {
+        return failure({
+            message: `Failed to scan directory: ${error}`,
+        });
+    }
+    return success(allPaths);
+}
+async function getGitignoresMap({ startDir, stopAtDir }) {
+    const gitignores = new Map();
+    let currentDir = startDir;
+    const stopAtDirParent = path.dirname(stopAtDir);
+    while (currentDir !== stopAtDirParent) {
+        const gitignorePath = path.join(currentDir, '.gitignore');
+        const hasGitignore = await fs.access(gitignorePath).then(() => true).catch(() => false);
+        if (hasGitignore) {
+            const gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+            gitignores.set(currentDir, ignore().add(gitignoreContent));
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return gitignores;
+}
+async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot }) {
+    try {
+        const items = await fs.readdir(dirPath);
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item);
+            try {
+                const stat = await fs.stat(itemPath);
+                let shouldIgnore = false;
+                for (const [gitignoreDir, gitignoreInstance] of gitignoresMap) {
+                    const relativePathFromGitignore = path.relative(gitignoreDir, itemPath);
+                    const isIgnored = gitignoreInstance.ignores(relativePathFromGitignore);
+                    if (isIgnored) {
+                        shouldIgnore = true;
+                        break;
+                    }
+                }
+                if (shouldIgnore) {
+                    continue;
+                }
+                allPaths.push({
+                    path: path.relative(projectRoot, itemPath),
+                    isDir: stat.isDirectory(),
+                });
+                if (stat.isDirectory()) {
+                    await scanDirectory({
+                        dirPath: itemPath,
+                        allPaths,
+                        gitignoresMap,
+                        projectRoot,
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`Cannot access ${itemPath}: ${error}`);
+            }
+        }
+    }
+    catch (error) {
+        throw new Error(`Cannot read directory ${dirPath}: ${error}`);
+    }
+}
+
+async function getContextStatus(params) {
+    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables = {}, contextVariables = {}, remoteName = "origin", verbose = false, } = params;
+    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 (!logResult.success)
+        return 'toDo';
+    const matchingHashes = logResult.data.stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const sp = line.indexOf(' ');
+        return {
+            hash: sp === -1 ? line : line.slice(0, sp),
+            subject: sp === -1 ? '' : line.slice(sp + 1),
+        };
+    })
+        .filter((c) => c.subject === commitMessage)
+        .map((c) => c.hash);
+    if (verbose) {
+        console.log('remoteName', remoteName);
+        console.log('baseBranch', baseBranch);
+        console.log('commitMessage', commitMessage);
+        console.log('matchingHashes', matchingHashes);
+    }
+    if (matchingHashes.length === 0)
+        return 'toDo';
+    const baseRef = `${remoteName}/${baseBranch}`;
+    for (const hash of matchingHashes) {
+        const isAncestor = await execAsync(`git merge-base --is-ancestor ${hash} ${baseRef}`, { cwd: projectRoot });
+        if (isAncestor.success)
+            return 'finished';
+    }
+    for (const hash of matchingHashes) {
+        const branches = await execAsync(`git branch -r --contains ${hash} --format=${shellSingleQuote('%(refname:short)')}`, { cwd: projectRoot });
+        if (!branches.success)
+            continue;
+        const branchList = branches.data.stdout
+            .trim()
+            .split('\n')
+            .map((b) => b.trim())
+            .filter((b) => b && b !== remoteName && b !== baseRef);
+        if (branchList.length > 0)
+            return 'branchPushed';
+    }
+    return 'toDo';
+}
+
+const VALID_CONTEXT_NAME = /^[a-zA-Z0-9_-]+$/;
+function validateContextListNames(contextList) {
+    const invalidNames = contextList
+        .filter((context) => !VALID_CONTEXT_NAME.test(context.name))
+        .map((context) => context.name);
+    if (invalidNames.length > 0) {
+        return `Invalid context name(s): ${invalidNames.join(', ')}. Context names must contain only letters, digits, underscores (_), and hyphens (-).`;
+    }
+    const seen = new Set();
+    const duplicateNames = [];
+    for (const context of contextList) {
+        if (seen.has(context.name)) {
+            if (!duplicateNames.includes(context.name)) {
+                duplicateNames.push(context.name);
+            }
+        }
+        else {
+            seen.add(context.name);
+        }
+    }
+    if (duplicateNames.length > 0) {
+        return `Duplicate context name(s): ${duplicateNames.join(', ')}. Context names must be unique.`;
+    }
+    return undefined;
+}
+
+async function getToDoContextList(params) {
+    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch } = params;
+    const codeBasePathsResult = await getCodeBasePaths({ cwd: projectRoot });
+    if (!codeBasePathsResult.success) {
+        return failure({
+            message: 'Failed to get code base paths',
+        });
+    }
+    const codeBasePaths = codeBasePathsResult.data;
+    const contextList = await getContextListFn({ codeBasePaths, lumpVariables });
+    const contextListValidationError = validateContextListNames(contextList);
+    if (contextListValidationError) {
+        return failure({
+            message: contextListValidationError,
+        });
+    }
+    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,
+            contextVariables: {}, // TODO: Remove contextVariables from getContextStatus, really not needed
+            gitCommitMessageFn,
+            lumpVariables,
+            projectRoot,
+            baseBranch,
+        });
+    }));
+    const contextStatusMap = new Map(allCtxNamesList.map((contextName, i) => [contextName, contextStatusList[i]]));
+    const contextListToDo = contextList
+        .filter((context, contextIndex) => {
+        const contextStatus = contextStatusList[contextIndex];
+        if (contextStatus && contextStatus !== 'toDo')
+            return false;
+        const deps = context.options?.dependsOnContexts;
+        if (deps && deps.length > 0) {
+            return deps.every(dep => contextStatusMap.get(dep) === 'finished');
+        }
+        return true;
+    })
+        .sort((a, b) => {
+        return (a.options?.priority || 0) - (b.options?.priority || 0);
+    });
+    console.log('contextListToDo', contextListToDo);
+    return success(contextListToDo);
+}
+
+const contextStatus = ['toDo', 'branchPushed', 'finished'];
+const contextStatusSchema = z.enum(contextStatus);
+
+const defaultGitCommitMessageFn = ({ context }) => {
+    return `LUMP:${context.name}`;
+};
+const defaultGitPushCommandFn = (input) => {
+    return `git push origin ${shellSingleQuote(input.branchName)}`;
+};
+const defaultGitAddCommandFn = () => {
+    return `git add .`;
+};
+const defaultGitCommitCommandFn = (input) => {
+    return `git commit -m ${shellSingleQuote(input.commitMessage)}`;
+};
+const defaultSetupWorkspaceFn = async (input) => {
+    const { baseBranch, branchName } = input;
+    return {
+        command: `
+        git switch ${baseBranch};
+        git reset --hard origin/${baseBranch};
+        git fetch --all;
+        git pull origin ${baseBranch};
+        git branch -D ${branchName};
+        git switch -c ${branchName};
+        `,
+        workspacePath: '.',
+    };
+};
+const defaultTeardownWorkspaceFn = async (input) => {
+    const { baseBranch } = input;
+    return `git switch ${baseBranch}`;
+};
+const defaultTeardownWorkspaceFnWithWorktree = async (input) => {
+    return "";
+};
+const defaultSetupWorkspaceFnWithWorktree = async (input) => {
+    const { baseBranch, branchName } = input;
+    const worktreePath = `lump-wkt/${branchName}`;
+    return {
+        command: `git switch ${baseBranch} &&
+        git pull origin ${baseBranch} &&
+        git worktree remove ${worktreePath}  &&
+        git branch -D ${branchName} &&
+        git push --delete origin ${branchName} &&
+        git worktree add -b ${branchName} ${worktreePath}`,
+        workspacePath: worktreePath,
+    };
+};
+
+async function runLump(input) {
+    const { baseBranch, branchFn, lumpVariables = {}, getContextListFn, gitAddCommandFn = defaultGitAddCommandFn, gitCommitCommandFn = defaultGitCommitCommandFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushCommandFn = defaultGitPushCommandFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, verbose = false, getKeepHistoryFilePathFn = () => undefined, } = input;
+    const contextListToDoResult = await getToDoContextList({
+        getContextListFn,
+        lumpVariables,
+        projectRoot,
+        baseBranch,
+        gitCommitMessageFn,
+    });
+    if (!contextListToDoResult.success) {
+        return set(contextListToDoResult, ['data', 'message'], "Error in runLump: Failed to get to do context list. Original Error: " + contextListToDoResult.data.message);
+    }
+    const contextListToDo = contextListToDoResult.data;
+    const nextContextsForBranchList = contextListToDo.slice(0, numberOfContextsPerBranch);
+    if (nextContextsForBranchList.length === 0) {
+        console.log('no next contexts for branch');
+        return success({
+            result: {
+                updatedGroupStatusRecord: {
+                    data: {},
+                },
+                branchName: '',
+                contextNames: [],
+                contextRunStateList: [],
+            },
+        });
+    }
+    const executeStepsResult = await executeStepsForContextList({
+        baseBranch: baseBranch,
+        branchFn: branchFn,
+        lumpVariables: lumpVariables,
+        contextList: nextContextsForBranchList,
+        gitAddCommandFn,
+        gitCommitCommandFn,
+        gitCommitMessageFn,
+        gitPushCommandFn,
+        projectRoot,
+        steps,
+        setupFn,
+        setupWorkspaceFn,
+        teardownFn,
+        teardownWorkspaceFn,
+        verbose,
+        getKeepHistoryFilePathFn,
+    });
+    if (!executeStepsResult.success) {
+        return set(executeStepsResult, ['data', 'message'], "Error in runLump: Failed to execute steps for context list. Original Error: " + executeStepsResult.data.message);
+    }
+    return success({
+        result: executeStepsResult.data,
+    });
+}
+
+export { collectStepsForContext, contextStatus, contextStatusSchema, decision, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, getCodeBasePaths, getContextStatus, getToDoContextList, runLump, set, shellBestEffort, shellSingleQuote, success, validateContextListNames };
+//# sourceMappingURL=index.js.map