@lumpcode/core 0.0.3 → 0.0.5

package/README.md

@@ -101,7 +101,7 @@ An array of `Step` objects that are executed sequentially for each context. Each
 | Field | Type | Description |
 |---|---|---|
 | `promptFn` | `PromptFn \| undefined` | Optional. Generates the prompt string from the current context, run state, and variables. When omitted, `commandFn` receives an empty prompt string. |
-| `commandFn` | `CommandFn` | Required. Returns `{ executable, args }` to run a subprocess, or `null` / `undefined` to skip execution while still running `postCommandExecFn`. |
+| `commandFn` | `CommandFn` | Required. Returns `{ executable, args, env? }` to run a subprocess, or `null` / `undefined` to skip execution while still running `postCommandExecFn`. Optional `env` merges over the parent process environment for that command only. |
 | `stepVariables` | `StepVariables \| undefined` | Optional extra variables passed into `promptFn`, `commandFn`, and `postCommandExecFn`. |
 | `postCommandExecFn` | `PostCommandExecFn \| undefined` | Optional hook called after the command finishes, receiving the command output. |
 | `timeoutMillis` | `number \| undefined` | Maximum time in milliseconds allowed for the command execution. Defaults to `1800000` (30 minutes). |
@@ -167,11 +167,13 @@ The array of prompt items (or dynamic prompt-generating functions) to execute fo
 
 How many contexts to include in a single branch. For example, `1` means each context gets its own branch; `5` groups up to five contexts per branch.
 
-#### `verbose`
+#### `logger`
 
-**Type:** `boolean` -- **Default:** `false`
+**Type:** `Logger` -- **Default:** `createConsoleLogger({})` when omitted
 
-When `true`, logs extra diagnostic information during workspace setup and prompt execution (e.g. branch names, commands, git status).
+Optional operational logger. CLI callers should pass an explicit logger from `createCliLogger` (after OR-merging lump `verbose` with `--verbose`). Library callers omit it for quiet defaults (info/warn/error only, no verbose detail).
+
+See [Logging](#logging) below.
 
 #### `getKeepHistoryFilePathFn`
 
@@ -284,6 +286,26 @@ An alternative **git-worktree-based** implementation is exported as `defaultSetu
 
 Cleans up the workspace after all contexts on a branch are done. The default switches back to the base branch only. A worktree variant is exported as `defaultTeardownWorkspaceFnWithWorktree`.
 
+## Logging
+
+Operational runtime output uses a small shared **`Logger`** type exported from `@lumpcode/core`:
+
+```typescript
+type Logger = {
+  error: (message: string) => void;
+  warn: (message: string) => void;
+  info: (message: string) => void;
+  verbose: (message: string) => void;
+  child: (prefix: string) => Logger;
+};
+```
+
+- **`createConsoleLogger({ verbose?, json?, prefix? })`** — console-backed implementation (`error` always prints; `verbose` gated by `verbose`; when `json: true`, non-error levels are suppressed).
+- **`noopLogger`** — no-op logger for tests.
+- **`formatExecFailureMessage({ label, failure })`** — user-facing shell/git failure strings.
+
+Pass **`logger`** on `RunLumpInput`. When omitted, the engine uses `createConsoleLogger({})` (operational errors/warnings/progress only; no verbose detail unless the logger you pass enables it).
+
 ## Return Value
 
 `runLump` returns a `Promise` that resolves to a discriminated union:

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

@@ -1,11 +1,8 @@
-import type { Context, ContextList, LumpVariables, PostCommandExecFn, Step, Steps, SetupFn } from '../../types';
+import type { CommandDescriptor, Context, ContextList, LumpVariables, PostCommandExecFn, Step, Steps, SetupFn } from '../../types';
 export type CollectedStep = {
     stepIndex: number | number[];
     prompt?: string;
-    command: {
-        executable: string;
-        args: string[];
-    } | null;
+    command: CommandDescriptor | null;
     postCommandExecFn?: PostCommandExecFn;
     stepVariables?: Step['stepVariables'];
     timeoutMillis?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/collectStepsForContext/main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,OAAO,EACP,WAAW,EAEX,aAAa,EACb,iBAAiB,EAEjB,IAAI,EACJ,KAAK,EACL,OAAO,EACV,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,aAAa,GAAG;IACxB,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;IACvD,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,aAAa,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,aAAa,CAAC;IAC7B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAsB,sBAAsB,CACxC,MAAM,EAAE,4BAA4B,GACrC,OAAO,CAAC,aAAa,EAAE,CAAC,CAwF1B"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/collectStepsForContext/main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,iBAAiB,EACjB,OAAO,EACP,WAAW,EAEX,aAAa,EACb,iBAAiB,EAEjB,IAAI,EACJ,KAAK,EACL,OAAO,EACV,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,aAAa,GAAG;IACxB,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,aAAa,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,aAAa,CAAC;IAC7B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAsB,sBAAsB,CACxC,MAAM,EAAE,4BAA4B,GACrC,OAAO,CAAC,aAAa,EAAE,CAAC,CA4F1B"}

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

@@ -1,10 +1,10 @@
-import { ContextList, ContextRunState, Failure } from "../../types";
+import { ContextList, ContextRunState, Failure, Logger } from "../../types";
 import type { RunLumpInput } from '../../usages';
 export type ExecuteStepsForContextListParams = Required<Pick<RunLumpInput, 'baseBranch' | 'branchFn' | 'lumpVariables' | 'steps' | 'setupFn' | 'teardownFn' | 'gitAddCommandFn' | 'gitCommitCommandFn' | 'gitPushCommandFn' | 'gitCommitMessageFn' | 'projectRoot' | 'setupWorkspaceFn' | 'teardownWorkspaceFn' | 'getKeepHistoryFilePathFn'>> & {
     contextList: ContextList;
-    verbose?: boolean;
+    logger?: Logger;
 };
-export declare function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, verbose, }: ExecuteStepsForContextListParams): Promise<Failure<{
+export declare function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, }: ExecuteStepsForContextListParams): Promise<Failure<{
     message: string;
 }> | import("../../types").Success<{
     branchName: string;

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,OAAO,EAIV,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAIjD,MAAM,MAAM,gCAAgC,GAAG,QAAQ,CAAC,IAAI,CACxD,YAAY,EACV,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,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,CAAA;AAED,wBAAsB,0BAA0B,CAAC,EAC7C,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,OAAO,GACV,EAAE,gCAAgC;aAyDa,MAAM;;;;;IAsNrD;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,OAAO,EACP,MAAM,EAIT,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAIjD,MAAM,MAAM,gCAAgC,GAAG,QAAQ,CAAC,IAAI,CACxD,YAAY,EACV,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;CACnB,CAAA;AAED,wBAAsB,0BAA0B,CAAC,EAC7C,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,GACtB,EAAE,gCAAgC;aAgEa,MAAM;;;;;IAyOrD;AAED,MAAM,MAAM,gCAAgC,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC"}

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

@@ -1,6 +1,7 @@
-import { CodeBasePath } from '../../types';
-export declare function getCodeBasePaths({ cwd, }: {
+import { CodeBasePath, Logger } from '../../types';
+export declare function getCodeBasePaths({ cwd, logger: loggerInput, }: {
     cwd: string;
+    logger?: Logger;
 }): Promise<import("../../types").Failure<{
     message: string;
 }> | import("../../types").Success<CodeBasePath[]>>;

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getCodeBasePaths/main.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAsB,gBAAgB,CAAC,EACnC,GAAG,GACN,EAAE;IACC,GAAG,EAAE,MAAM,CAAC;CACf;;oDAkBA"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getCodeBasePaths/main.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAsB,gBAAgB,CAAC,EACnC,GAAG,EACH,MAAM,EAAE,WAAW,GACtB,EAAE;IACC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;;oDAoBA"}

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

@@ -1,4 +1,4 @@
-import { ContextStatus, LumpVariables } from "../../types";
+import { ContextStatus, Logger, LumpVariables } from "../../types";
 import { GitCommitMessageFn } from "../../types/GitCommitMessageFn";
 export declare function getContextStatus(params: {
     contextName: string;
@@ -8,6 +8,6 @@ export declare function getContextStatus(params: {
     lumpVariables?: LumpVariables;
     contextVariables?: Record<string, string>;
     remoteName?: string;
-    verbose?: boolean;
+    logger?: Logger;
 }): Promise<ContextStatus>;
 //# sourceMappingURL=main.d.ts.map

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,aAAa,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIpE,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,OAAO,CAAC,aAAa,CAAC,CA+EzB"}
+{"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;AAIpE,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,aAAa,CAAC,CA6EzB"}

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

@@ -1,4 +1,4 @@
-import { GetContextListFn, LumpVariables } from "../../types";
+import { GetContextListFn, Logger, LumpVariables } from "../../types";
 import { GitCommitMessageFn } from "../../types/GitCommitMessageFn";
 export declare function getToDoContextList(params: {
     getContextListFn: GetContextListFn;
@@ -6,6 +6,7 @@ export declare function getToDoContextList(params: {
     gitCommitMessageFn: GitCommitMessageFn;
     projectRoot: string;
     baseBranch: string;
+    logger?: Logger;
 }): Promise<import("../../types").Failure<{
     message: string;
 }> | import("../../types").Success<import("../../types").Context[]>>;

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getToDoContextList/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACtB;;qEA6DA"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getToDoContextList/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;;qEA8DA"}

package/dist/index.cjs

@@ -211,6 +211,78 @@ function resolveSpawnExecutable(executable, args) {
     return { executable: resolved, args };
 }
 
+function formatMessage(prefix, message) {
+    if (!prefix)
+        return message;
+    return `${prefix} ${message}`;
+}
+function createConsoleLogger(input) {
+    const verboseEnabled = !!input.verbose;
+    const suppressNonError = !!input.json;
+    const prefix = input.prefix;
+    function makeLogger(currentPrefix) {
+        return {
+            error(message) {
+                console.error(formatMessage(currentPrefix, message));
+            },
+            warn(message) {
+                if (suppressNonError)
+                    return;
+                console.warn(formatMessage(currentPrefix, message));
+            },
+            info(message) {
+                if (suppressNonError)
+                    return;
+                console.log(formatMessage(currentPrefix, message));
+            },
+            verbose(message) {
+                if (suppressNonError || !verboseEnabled)
+                    return;
+                console.log(formatMessage(currentPrefix, message));
+            },
+            child(childPrefix) {
+                const nextPrefix = currentPrefix ? `${currentPrefix} ${childPrefix}` : childPrefix;
+                return makeLogger(nextPrefix);
+            },
+        };
+    }
+    return makeLogger(prefix);
+}
+
+const noopLogger = {
+    error: () => { },
+    warn: () => { },
+    info: () => { },
+    verbose: () => { },
+    child: () => noopLogger,
+};
+
+function firstNonEmptyLine(value) {
+    if (value == null)
+        return undefined;
+    const text = typeof value === 'string' ? value : String(value);
+    const line = text
+        .split(/\r?\n/)
+        .map((part) => part.trim())
+        .find((part) => part.length > 0);
+    return line || undefined;
+}
+function shortExecDetail(data) {
+    return (firstNonEmptyLine(data.stderr)
+        ?? firstNonEmptyLine(data.info?.stderr)
+        ?? firstNonEmptyLine(data.stdout)
+        ?? firstNonEmptyLine(data.info?.stdout));
+}
+function formatExecFailureMessage(input) {
+    const { label, failure } = input;
+    const data = failure.data;
+    const detail = shortExecDetail(data) ?? data.message;
+    if (typeof data.code === 'number') {
+        return `${label} failed (exit ${data.code}): ${detail}`;
+    }
+    return `${label} failed: ${detail}`;
+}
+
 const execAsyncBase = node_util.promisify(node_child_process.exec);
 async function execAsync(command, options) {
     const { stdout, stderr, hasErrored } = await execAsyncBase(command, { cwd: options?.cwd })
@@ -342,7 +414,11 @@ async function collectStepsForContext(params) {
                 stepIndex: compositeStepIndex,
                 ...(prompt.length > 0 && { prompt }),
                 command: command != null
-                    ? { executable: command.executable, args: command.args }
+                    ? {
+                        executable: command.executable,
+                        args: command.args,
+                        ...(command.env != null ? { env: command.env } : {}),
+                    }
                     : null,
                 postCommandExecFn,
                 stepVariables,
@@ -354,16 +430,17 @@ async function collectStepsForContext(params) {
     return collectedSteps;
 }
 
-async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, verbose, }) {
+async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, }) {
+    const logger = loggerInput ?? createConsoleLogger({});
     const contextNames = contextList.map(context => context.name);
-    log('contextNames', contextNames);
+    logger.verbose(`contextNames ${JSON.stringify(contextNames)}`);
     const contextRunStateList = [];
     const branchName = await branchFn({
         contextList,
         contextRunStateList,
         lumpVariables,
     });
-    log('branchName', branchName);
+    logger.verbose(`branchName ${branchName}`);
     const injectedGitAndWorkspaceFnsInput = {
         baseBranch,
         branchName,
@@ -371,22 +448,25 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
         workspacePath: '.',
     };
     const { command: setupWorkspaceCommand, workspacePath } = await setupWorkspaceFn(injectedGitAndWorkspaceFnsInput);
-    log('setupWorkspaceCommand', setupWorkspaceCommand);
-    log('workspacePath', workspacePath);
+    logger.verbose(`setupWorkspaceCommand ${setupWorkspaceCommand}`);
+    logger.verbose(`workspacePath ${workspacePath}`);
     if (setupWorkspaceCommand) {
         const setupWorkspaceCommandExec = await execAsync(setupWorkspaceCommand, {
             cwd: projectRoot,
         });
-        log('setupWorkspaceCommandExec', setupWorkspaceCommandExec);
+        logger.verbose(`setupWorkspaceCommandExec ${JSON.stringify(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);
+    logger.verbose(`gitStatusCommand ${JSON.stringify(gitStatusCommand.data)}`);
     injectedGitAndWorkspaceFnsInput.workspacePath = workspacePath;
     for (let i = 0; i < contextList.length; i++) {
         const context = contextList[i];
+        logger.info(contextList.length > 1
+            ? `Running context "${context.name}" (${i + 1}/${contextList.length})`
+            : `Running context "${context.name}"`);
         const setupResult = await setupFn({
             contextList,
             lumpVariables,
@@ -418,8 +498,8 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                     await walkAndExecuteSteps(subSteps, nextCallHeadIndex);
                     continue;
                 }
-                log('step', step);
-                const { commandFn, stepVariables, promptFn, postCommandExecFn, timeoutMillis = 1000 * 60 * 30, } = step;
+                logger.verbose(`step ${JSON.stringify(step)}`);
+                const { commandFn, stepVariables, promptFn, postCommandExecFn, continueOnError, timeoutMillis = 1000 * 60 * 30, } = step;
                 const prompt = promptFn
                     ? await promptFn({
                         context,
@@ -440,23 +520,40 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                     workspacePath,
                 });
                 let commandResult = '';
+                let commandSucceeded = true;
                 if (command != null) {
-                    const { executable, args } = command;
-                    log('command for prompt', executable, args);
-                    log('workspacePath', workspacePath);
+                    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(executable, args, timeoutMillis, {
                         stdio: ['inherit', 'pipe', 'pipe'],
                         cwd: workspacePath,
+                        ...(env != null ? { env: { ...process.env, ...env } } : {}),
                     });
-                    log('commandExec', commandExec);
+                    logger.verbose(`commandExec ${JSON.stringify(commandExec)}`);
                     if (!commandExec.success) {
-                        stepWalkFailure = set(commandExec, ['data', 'message'], `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`);
-                        return;
+                        if (!continueOnError) {
+                            stepWalkFailure = set(commandExec, ['data', 'message'], `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`);
+                            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)}`);
                     }
-                    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,
@@ -468,9 +565,9 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                     stepVariables,
                     projectRoot,
                 };
-                log('context is', context);
+                logger.verbose(`context is ${JSON.stringify(context)}`);
                 const keepHistoryFilePath = getKeepHistoryFilePathFn(context) || '';
-                log('keepHistoryFilePath', keepHistoryFilePath);
+                logger.verbose(`keepHistoryFilePath ${keepHistoryFilePath}`);
                 if (!!command && keepHistoryFilePath.length > 0) {
                     const makeHistoryFileIfNotExists = async () => {
                         if (await fs$1.stat(keepHistoryFilePath).then(() => true).catch(() => false))
@@ -480,13 +577,13 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                     };
                     await makeHistoryFileIfNotExists();
                     const historyFileContent = await fs$1.readFile(keepHistoryFilePath, 'utf-8');
-                    log('historyFileContent', historyFileContent);
+                    logger.verbose(`historyFileContent ${historyFileContent}`);
                     const history = JSON.parse(historyFileContent);
-                    log('history', history);
+                    logger.verbose(`history ${JSON.stringify(history)}`);
                     history.push({
                         ...postCommandExecFnInput,
                     });
-                    log('history after push', history);
+                    logger.verbose(`history after push ${JSON.stringify(history)}`);
                     await fs$1.writeFile(keepHistoryFilePath, JSON.stringify(history, null, 2), 'utf-8');
                 }
                 if (postCommandExecFn) {
@@ -509,7 +606,7 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
             context,
         };
         const gitAddCommand = await execAsync(gitAddCommandFn(perContextInput), { cwd: workspacePath });
-        log('gitAddCommand', gitAddCommand);
+        logger.verbose(`gitAddCommand ${JSON.stringify(gitAddCommand)}`);
         if (!gitAddCommand.success) {
             return set(gitAddCommand, ['data', 'message'], `Failed to add the changes for context ${context.name}: ${gitAddCommand.data.message}`);
         }
@@ -518,21 +615,27 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
             ...perContextInput,
             commitMessage,
         }), { cwd: workspacePath });
-        log('commitCommand', commitCommand);
+        logger.verbose(`commitCommand ${JSON.stringify(commitCommand)}`);
         if (!commitCommand.success) {
-            log(`Failed to commit the changes for context ${context.name}:`, commitCommand.data);
+            logger.error(formatExecFailureMessage({
+                label: `git commit for context ${context.name}`,
+                failure: commitCommand,
+            }));
         }
     }
     const pushCommand = await execAsync(gitPushCommandFn(injectedGitAndWorkspaceFnsInput), { cwd: workspacePath });
-    log('pushCommand', pushCommand);
+    logger.verbose(`pushCommand ${JSON.stringify(pushCommand)}`);
     if (!pushCommand.success) {
-        log(`Failed to push the changes on branch ${branchName}: ${pushCommand.data.message}`);
+        logger.error(formatExecFailureMessage({
+            label: `git push on branch ${branchName}`,
+            failure: pushCommand,
+        }));
     }
     const teardownWorkspaceCommand = await teardownWorkspaceFn(injectedGitAndWorkspaceFnsInput);
-    console.log('teardownWorkspaceCommand', teardownWorkspaceCommand);
+    logger.verbose(`teardownWorkspaceCommand ${teardownWorkspaceCommand}`);
     if (teardownWorkspaceCommand) {
         const teardownWorkspaceCommandExec = await execAsync(teardownWorkspaceCommand, { cwd: workspacePath });
-        console.log('teardownWorkspaceCommandExec', teardownWorkspaceCommandExec);
+        logger.verbose(`teardownWorkspaceCommandExec ${JSON.stringify(teardownWorkspaceCommandExec)}`);
         if (!teardownWorkspaceCommandExec.success) {
             return set(teardownWorkspaceCommandExec, ['data', 'message'], `Failed to teardown the workspace: ${teardownWorkspaceCommandExec.data.message}`);
         }
@@ -542,14 +645,10 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
         contextNames,
         contextRunStateList,
     });
-    function log(...params) {
-        if (verbose) {
-            console.log(...params);
-        }
-    }
 }
 
-async function getCodeBasePaths({ cwd, }) {
+async function getCodeBasePaths({ cwd, logger: loggerInput, }) {
+    const logger = loggerInput ?? createConsoleLogger({});
     const allPaths = [];
     const gitignoresMap = await getGitignoresMap({ startDir: cwd, stopAtDir: cwd });
     try {
@@ -558,6 +657,7 @@ async function getCodeBasePaths({ cwd, }) {
             allPaths,
             gitignoresMap,
             projectRoot: cwd,
+            logger,
         });
     }
     catch (error) {
@@ -582,7 +682,7 @@ async function getGitignoresMap({ startDir, stopAtDir }) {
     }
     return gitignores;
 }
-async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot }) {
+async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot, logger }) {
     try {
         const items = await fs__namespace$1.readdir(dirPath);
         for (const item of items) {
@@ -611,11 +711,12 @@ async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot })
                         allPaths,
                         gitignoresMap,
                         projectRoot,
+                        logger,
                     });
                 }
             }
             catch (error) {
-                console.warn(`Cannot access ${itemPath}: ${error}`);
+                logger.warn(`Cannot access ${itemPath}: ${error}`);
             }
         }
     }
@@ -625,7 +726,7 @@ async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot })
 }
 
 async function getContextStatus(params) {
-    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables = {}, contextVariables = {}, remoteName = "origin", verbose = false, } = params;
+    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables = {}, contextVariables = {}, remoteName = "origin", logger, } = params;
     const commitMessage = gitCommitMessageFn({
         context: { name: contextName, variables: contextVariables },
         lumpVariables,
@@ -637,7 +738,7 @@ async function getContextStatus(params) {
     const logResult = await execAsync(`git log --remotes=${remoteName} -F --grep=${shellSingleQuote(commitMessage)} --format=${shellSingleQuote('%H %s')}`, { cwd: projectRoot });
     if (!logResult.success)
         return 'toDo';
-    console.log('logResult', logResult.data);
+    logger?.verbose(`logResult ${JSON.stringify(logResult.data)}`);
     const logResultOutput = logResult.data.stdout || logResult.data.stderr || '';
     const matchingHashes = logResultOutput
         .split('\n')
@@ -652,12 +753,10 @@ async function getContextStatus(params) {
     })
         .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);
-    }
+    logger?.verbose(`remoteName ${remoteName}`);
+    logger?.verbose(`baseBranch ${baseBranch}`);
+    logger?.verbose(`commitMessage ${commitMessage}`);
+    logger?.verbose(`matchingHashes ${JSON.stringify(matchingHashes)}`);
     if (matchingHashes.length === 0)
         return 'toDo';
     const baseRef = `${remoteName}/${baseBranch}`;
@@ -708,8 +807,8 @@ function validateContextListNames(contextList) {
 }
 
 async function getToDoContextList(params) {
-    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch } = params;
-    const codeBasePathsResult = await getCodeBasePaths({ cwd: projectRoot });
+    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch, logger } = params;
+    const codeBasePathsResult = await getCodeBasePaths({ cwd: projectRoot, logger });
     if (!codeBasePathsResult.success) {
         return failure({
             message: 'Failed to get code base paths',
@@ -734,6 +833,7 @@ async function getToDoContextList(params) {
             lumpVariables,
             projectRoot,
             baseBranch,
+            logger,
         });
     }));
     const contextStatusMap = new Map(allCtxNamesList.map((contextName, i) => [contextName, contextStatusList[i]]));
@@ -751,7 +851,7 @@ async function getToDoContextList(params) {
         .sort((a, b) => {
         return (a.options?.priority || 0) - (b.options?.priority || 0);
     });
-    console.log('contextListToDo', contextListToDo);
+    logger?.verbose(`contextListToDo ${JSON.stringify(contextListToDo)}`);
     return success(contextListToDo);
 }
 
@@ -768,7 +868,7 @@ const defaultGitAddCommandFn = () => {
     return `git add .`;
 };
 const defaultGitCommitCommandFn = (input) => {
-    return `git commit -m ${shellSingleQuote(input.commitMessage)}`;
+    return `git commit --allow-empty -m ${shellSingleQuote(input.commitMessage)}`;
 };
 const defaultSetupWorkspaceFn = async (input) => {
     const { baseBranch, branchName } = input;
@@ -806,13 +906,15 @@ const defaultSetupWorkspaceFnWithWorktree = async (input) => {
 };
 
 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 { baseBranch, branchFn, lumpVariables = {}, 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, } = input;
+    const logger = loggerInput ?? createConsoleLogger({});
     const contextListToDoResult = await getToDoContextList({
         getContextListFn,
         lumpVariables,
         projectRoot,
         baseBranch,
         gitCommitMessageFn,
+        logger,
     });
     if (!contextListToDoResult.success) {
         return set(contextListToDoResult, ['data', 'message'], "Error in runLump: Failed to get to do context list. Original Error: " + contextListToDoResult.data.message);
@@ -820,7 +922,7 @@ async function runLump(input) {
     const contextListToDo = contextListToDoResult.data;
     const nextContextsForBranchList = contextListToDo.slice(0, numberOfContextsPerBranch);
     if (nextContextsForBranchList.length === 0) {
-        console.log('no next contexts for branch');
+        logger.verbose('no next contexts for branch');
         return success({
             result: {
                 updatedGroupStatusRecord: {
@@ -847,7 +949,7 @@ async function runLump(input) {
         setupWorkspaceFn,
         teardownFn,
         teardownWorkspaceFn,
-        verbose,
+        logger,
         getKeepHistoryFilePathFn,
     });
     if (!executeStepsResult.success) {
@@ -861,6 +963,7 @@ async function runLump(input) {
 exports.collectStepsForContext = collectStepsForContext;
 exports.contextStatus = contextStatus;
 exports.contextStatusSchema = contextStatusSchema;
+exports.createConsoleLogger = createConsoleLogger;
 exports.decision = decision;
 exports.defaultGitAddCommandFn = defaultGitAddCommandFn;
 exports.defaultGitCommitCommandFn = defaultGitCommitCommandFn;
@@ -874,9 +977,11 @@ exports.execAsync = execAsync;
 exports.execBinary = execBinary;
 exports.executeStepsForContextList = executeStepsForContextList;
 exports.failure = failure;
+exports.formatExecFailureMessage = formatExecFailureMessage;
 exports.getCodeBasePaths = getCodeBasePaths;
 exports.getContextStatus = getContextStatus;
 exports.getToDoContextList = getToDoContextList;
+exports.noopLogger = noopLogger;
 exports.resolveSpawnExecutable = resolveSpawnExecutable;
 exports.runLump = runLump;
 exports.set = set;