@lumpcode/core 0.1.1 → 0.2.0

package/dist/index.js

@@ -3584,32 +3584,54 @@ async function killProcessTree(input) {
 }
 
 const execAsyncBase = promisify(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) {
@@ -3827,28 +3849,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)}`);
@@ -3874,7 +3905,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 });
@@ -4056,43 +4089,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 {
@@ -4357,14 +4389,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;
@@ -4402,7 +4431,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({
@@ -4437,10 +4466,9 @@ async function runLump(input) {
         branchFn: branchFn,
         lumpVariables: lumpVariables,
         contextList: nextContextsForBranchList,
-        gitAddCommandFn,
-        gitCommitCommandFn,
+        gitAddCommitFn,
         gitCommitMessageFn,
-        gitPushCommandFn,
+        gitPushFn,
         projectRoot,
         steps,
         setupFn,
@@ -4459,5 +4487,5 @@ async function runLump(input) {
     });
 }
 
-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 };
+export { GIT_LOG_HASH_BODY_FORMAT, appendHistoryEntry, collectStepsForContext, commitMessageIncludesMarker, contextStatus, createConsoleLogger, defaultGitAddCommitFn, defaultGitCommitMessageFn, defaultGitPushFn, 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