@lumpcode/core 0.1.1 → 0.2.0

package/README.md

@@ -248,23 +248,25 @@ type GitCommitMessageFn = (input: {
 
 Maps a context to its normalized git commit message. **The returned message must be unique per context** -- it is the source of truth used to track whether a context has already been processed (see [Context Tracking with Git Commits](#context-tracking-with-git-commits)).
 
-### `gitAddCommandFn`
+### `gitAddCommitFn`
 
-**Type:** `GitAddCommandFn` -- **Default:** `git add .`
+**Type:** `GitAddCommitFn` -- **Default:** ``git add . && git commit --allow-empty -m <commitMessage>``
 
-Customize the git add command. Receives `{ baseBranch, branchName, contextList, workspacePath, context }` and is invoked **once per context**, right before that context's commit.
+Per-context add+commit. Receives `{ baseBranch, branchName, workspacePath, context, commitMessage }` (no `contextList`) and returns a `Success` / `Failure` result:
 
-### `gitCommitCommandFn`
+| Return | Behavior |
+| --- | --- |
+| `success(string)` | Core runs that shell string with `cwd: workspacePath` |
+| `success(null \| undefined)` | No-op (injector already did the work, or intentional skip) |
+| `success('')` / `failure(msg)` / throw | Hard-fail the run with `reason: 'gitAddCommitFailed'` |
 
-**Type:** `GitCommitCommandFn` -- **Default:** ``git commit -m "${commitMessage}"``
+Invoked **once per context** after `teardownFn`, producing exactly one commit per context on the work branch.
 
-Customize the git commit command. Receives the same input as `gitAddCommandFn` plus `{ commitMessage }`. Invoked **once per context**, producing exactly one commit per context on the work branch.
+### `gitPushFn`
 
-### `gitPushCommandFn`
+**Type:** `GitPushFn` -- **Default:** ``git push origin <branchName>``
 
-**Type:** `GitPushCommandFn` -- **Default:** ``git push origin ${branchName}``
-
-Customize the git push command. Invoked **once per branch**, after all per-context commits are made.
+Once-per-branch push after all per-context add+commits succeed. Same Success / Failure payload rules as `gitAddCommitFn`, except failures are **log-only** (the run stays successful).
 
 ### `setupWorkspaceFn`
 
@@ -275,7 +277,7 @@ Prepares the workspace before prompt execution. It returns an object with two fi
 - `command` — the shell command to run (e.g. checkout the base branch, fetch, create the work branch).
 - `workspacePath` — the directory where all subsequent operations (prompt execution, git add/commit/push) will take place. The default implementation returns `'.'`, so those commands run with `cwd: '.'` (the **host process's current working directory**). If your process's cwd is not `projectRoot`, pass an absolute path (e.g. `projectRoot` or a worktree path) so behavior is unambiguous.
 
-> **Where commands run:** `setupWorkspaceFn` is the only function whose returned `command` runs at `projectRoot`. All other function parameters that return commands (`gitAddCommandFn`, `gitCommitCommandFn`, `gitPushCommandFn`, `commandFn`, `teardownWorkspaceFn`) execute their commands at `workspacePath`.
+> **Where commands run:** `setupWorkspaceFn` is the only function whose returned `command` runs at `projectRoot`. All other function parameters that return commands (`gitAddCommitFn`, `gitPushFn`, `commandFn`, `teardownWorkspaceFn`) execute their commands at `workspacePath`.
 
 The default implementation command checks out the base branch, fetches, pulls, deletes and re-creates the work branch (with `cwd: projectRoot` for this setup command only):
 
@@ -510,10 +512,10 @@ flowchart TD
     LoopStart --> Setup["setupFn()"]
     Setup --> ExecPrompts["Execute steps sequentially"]
     ExecPrompts --> Teardown["teardownFn()"]
-    Teardown --> AddCommit["git add + git commit -m gitCommitMessageFn(context)"]
+    Teardown --> AddCommit["gitAddCommitFn (commitMessage from gitCommitMessageFn)"]
     AddCommit --> LoopCheck{"More contexts?"}
     LoopCheck -->|Yes| LoopStart
-    LoopCheck -->|No| Push["gitPushCommandFn (branch only)"]
+    LoopCheck -->|No| Push["gitPushFn (branch only)"]
     Push --> TeardownWorkspace["teardownWorkspaceFn()"]
     TeardownWorkspace --> Done["Return Success or Failure"]
 ```

package/dist/helpers/execAsync/main.d.ts

@@ -1,14 +1,19 @@
-export declare function execAsync(command: string, options?: {
-    cwd?: string;
-}): Promise<import("../..").Failure<{
+import type { Failure, Success } from '../../types';
+export type ExecAsyncFailureReason = 'timeout' | 'exit';
+export type ExecAsyncFailure = {
     message: string;
+    reason: ExecAsyncFailureReason;
     info: {
         command: string;
-        stdout: any;
-        stderr: any;
+        stdout: unknown;
+        stderr: unknown;
     };
-}> | import("../..").Success<{
-    stdout: any;
-    stderr: any;
-}>>;
+};
+export declare function execAsync(command: string, options?: {
+    cwd?: string;
+    timeoutMillis?: number;
+}): Promise<Success<{
+    stdout: string;
+    stderr: string;
+}> | Failure<ExecAsyncFailure>>;
 //# sourceMappingURL=main.d.ts.map

package/dist/helpers/execAsync/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/execAsync/main.ts"],"names":[],"mappings":"AAMA,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;IA4B1E"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/execAsync/main.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAQpD,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,MAAM,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,IAAI,EAAE;QACF,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;KACnB,CAAC;CACL,CAAC;AAoBF,wBAAsB,SAAS,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GACnD,OAAO,CAAC,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CA4BlF"}

package/dist/helpers/executeStepsForContextList/main.d.ts

@@ -1,19 +1,14 @@
-import { ContextList, ContextRunState, ExecuteStepsFailureData, Failure, Logger, LumpVariables, StepVariables } from "../../types";
+import { ContextList, ContextRunState, Failure, Logger, LumpVariables, StepVariables, Success } from "../../types";
 import type { RunLumpInput } from '../../usages';
-export type ExecuteStepsForContextListParams<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = Required<Pick<RunLumpInput<V, SV>, 'baseBranch' | 'branchFn' | 'lumpVariables' | 'steps' | 'setupFn' | 'teardownFn' | 'gitAddCommandFn' | 'gitCommitCommandFn' | 'gitPushCommandFn' | 'gitCommitMessageFn' | 'projectRoot' | 'setupWorkspaceFn' | 'teardownWorkspaceFn' | 'getKeepHistoryFilePathFn'>> & {
+export type ExecuteStepsForContextListParams<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = Required<Pick<RunLumpInput<V, SV>, 'baseBranch' | 'branchFn' | 'lumpVariables' | 'steps' | 'setupFn' | 'teardownFn' | 'gitAddCommitFn' | 'gitPushFn' | 'gitCommitMessageFn' | 'projectRoot' | 'setupWorkspaceFn' | 'teardownWorkspaceFn' | 'getKeepHistoryFilePathFn'>> & {
     contextList: ContextList;
     logger?: Logger;
     /** When aborted, in-flight commands are killed and the step walk stops (ignores continueOnError). */
     signal?: AbortSignal;
 };
-export declare function executeStepsForContextList<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, signal, }: ExecuteStepsForContextListParams<V, SV>): Promise<Failure<{
+export declare function executeStepsForContextList<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommitFn, gitPushFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, signal, }: ExecuteStepsForContextListParams<V, SV>): Promise<Failure<{
     message: string;
-    info: {
-        command: string;
-        stdout: any;
-        stderr: any;
-    };
-}> | Failure<ExecuteStepsFailureData> | import("../..").Success<{
+}> | Success<{
     branchName: string;
     contextNames: string[];
     contextRunStateList: ContextRunState[];

package/dist/helpers/executeStepsForContextList/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/executeStepsForContextList/main.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,WAAW,EACX,eAAe,EACf,uBAAuB,EACvB,OAAO,EACP,MAAM,EACN,aAAa,EAMb,aAAa,EAChB,MAAM,aAAa,CAAC;AASrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AA0FjD,MAAM,MAAM,gCAAgC,CACxC,CAAC,SAAS,aAAa,GAAG,aAAa,EACvC,EAAE,SAAS,aAAa,GAAG,aAAa,IACxC,QAAQ,CAAC,IAAI,CACb,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,EACjB,YAAY,GACZ,UAAU,GACV,eAAe,GACf,OAAO,GACP,SAAS,GACT,YAAY,GACZ,iBAAiB,GACjB,oBAAoB,GACpB,kBAAkB,GAClB,oBAAoB,GACpB,aAAa,GACb,kBAAkB,GAClB,qBAAqB,GACrB,0BAA0B,CAC/B,CAAC,GAAG;IACD,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB,CAAA;AAED,wBAAsB,0BAA0B,CAC5C,CAAC,SAAS,aAAa,GAAG,aAAa,EACvC,EAAE,SAAS,aAAa,GAAG,aAAa,EAC1C,EACE,UAAU,EACV,QAAQ,EACR,aAAa,EACb,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,KAAK,EACL,OAAO,EACP,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,wBAAwB,EACxB,MAAM,EAAE,WAAW,EACnB,MAAM,GACT,EAAE,gCAAgC,CAAC,CAAC,EAAE,EAAE,CAAC;;;;;;;;;;;IAkWzC;AAED,MAAM,MAAM,gCAAgC,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/executeStepsForContextList/main.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,WAAW,EACX,eAAe,EAEf,OAAO,EACP,MAAM,EACN,aAAa,EAMb,aAAa,EACb,OAAO,EACV,MAAM,aAAa,CAAC;AASrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAuGjD,MAAM,MAAM,gCAAgC,CACxC,CAAC,SAAS,aAAa,GAAG,aAAa,EACvC,EAAE,SAAS,aAAa,GAAG,aAAa,IACxC,QAAQ,CAAC,IAAI,CACb,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,EACjB,YAAY,GACZ,UAAU,GACV,eAAe,GACf,OAAO,GACP,SAAS,GACT,YAAY,GACZ,gBAAgB,GAChB,WAAW,GACX,oBAAoB,GACpB,aAAa,GACb,kBAAkB,GAClB,qBAAqB,GACrB,0BAA0B,CAC/B,CAAC,GAAG;IACD,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qGAAqG;IACrG,MAAM,CAAC,EAAE,WAAW,CAAC;CACxB,CAAA;AAED,wBAAsB,0BAA0B,CAC5C,CAAC,SAAS,aAAa,GAAG,aAAa,EACvC,EAAE,SAAS,aAAa,GAAG,aAAa,EAC1C,EACE,UAAU,EACV,QAAQ,EACR,aAAa,EACb,WAAW,EACX,cAAc,EACd,SAAS,EACT,kBAAkB,EAClB,WAAW,EACX,KAAK,EACL,OAAO,EACP,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,wBAAwB,EACxB,MAAM,EAAE,WAAW,EACnB,MAAM,GACT,EAAE,gCAAgC,CAAC,CAAC,EAAE,EAAE,CAAC;;;;;;IA6VzC;AAED,MAAM,MAAM,gCAAgC,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC"}

package/dist/index.cjs

@@ -3605,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) {
@@ -3848,28 +3870,37 @@ async function awaitUnlessAborted(work, signal) {
         });
     });
 }
-async function runOptionalGitCommand(input) {
-    const { label, getCommand, cwd, logger } = input;
+/**
+ * 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' };
+        }
+        const execResult = await execAsync(command, { cwd });
+        logger.verbose(`${execLabel} ${JSON.stringify(execResult)}`);
+        if (!execResult.success) {
+            return { status: 'failed', detail: execResult.data.message };
         }
-        return 'ok';
+        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)}`);
@@ -3895,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 });
@@ -4077,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 {
@@ -4378,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;
@@ -4423,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({
@@ -4458,10 +4487,9 @@ async function runLump(input) {
         branchFn: branchFn,
         lumpVariables: lumpVariables,
         contextList: nextContextsForBranchList,
-        gitAddCommandFn,
-        gitCommitCommandFn,
+        gitAddCommitFn,
         gitCommitMessageFn,
-        gitPushCommandFn,
+        gitPushFn,
         projectRoot,
         steps,
         setupFn,
@@ -4486,10 +4514,9 @@ 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;