@lumpcode/core 0.1.0 → 0.1.1

package/README.md

@@ -422,7 +422,7 @@ const steps: Steps = [
 
 ## Context Tracking with Git Commits
 
-Lumpcode uses normalized git commit messages to record which contexts have already been processed. Each completed context contributes **exactly one commit** whose subject equals `gitCommitMessageFn({ context, ... })`. On every subsequent call to `runLump`, contexts whose normalized commit message is already present on a remote branch are skipped so the run only works on what remains. This lets you call `runLump` repeatedly (e.g. in a cron job) and each invocation picks up where the previous one left off, progressively working through the full context list without ever re-processing a context.
+Lumpcode uses normalized git commit messages to record which contexts have already been processed. Each completed context contributes **exactly one commit** whose message contains the string returned by `gitCommitMessageFn({ context, ... })` (written as the subject; still matched if squash moves it into the body). On every subsequent call to `runLump`, contexts whose marker is already present on a remote branch are skipped so the run only works on what remains. This lets you call `runLump` repeatedly (e.g. in a cron job) and each invocation picks up where the previous one left off, progressively working through the full context list without ever re-processing a context.
 
 > If you'd rather not wire up your own scheduler, [@lumpcode/cli](https://www.npmjs.com/package/@lumpcode/cli) ships a built-in daemon (`lumpcode start`) that calls `runLump` on a tick, with concurrent-branch limits and per-lump enable/disable already wired in.
 
@@ -434,7 +434,7 @@ By default, a context named `my_component_ts` produces a commit with the subject
 LUMP:my_component_ts
 ```
 
-You can customize this via the `[gitCommitMessageFn](#gitcommitmessagefn)` parameter. The returned subject **must be unique per context** -- it is the only thing tying the commit back to its context.
+You can customize this via the `[gitCommitMessageFn](#gitcommitmessagefn)` parameter. The returned string **must be unique per context** -- it is the only thing tying the commit back to its context. Status matches that string anywhere in the full commit message, as long as it is not a prefix of a longer `[A-Za-z0-9_-]*` token (`foo` does not match `foo-bar`).
 
 ### Context statuses
 
@@ -458,7 +458,7 @@ A context with `dependsOnContexts` is only eligible when **all** of its listed d
 
 ```bash
 git fetch --all
-git log --remotes=origin --grep="^LUMP:" --format='%H %s'
+git log --remotes=origin -F --grep="LUMP:" --format='%H %s'
 ```
 
 **Check if a specific context has been processed (any remote ref):**

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;AA4BjD,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;;;;;;;;;;;IAuUzC;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,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"}

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getContextStatus/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAKpE,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAAE,MAAM,EAAE;IACpF,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,aAAa,CAAC,CAwEzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getContextStatus/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAUpE,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAAE,MAAM,EAAE;IACpF,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,OAAO,CAAC,aAAa,CAAC,CAwEzB"}

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) {
@@ -3766,6 +3800,54 @@ 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 {
@@ -3825,6 +3907,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 +3923,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 {
@@ -4159,13 +4255,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}`);
@@ -4384,8 +4480,10 @@ 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;
@@ -4408,6 +4506,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;