@lumpcode/core 0.1.0 → 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,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 {
@@ -3804,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})`
@@ -3816,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 {
@@ -4138,13 +4234,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}`);
@@ -4363,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, refreshRemoteTrackingRefs, 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