hammerkit 1.4.0-beta.6 → 1.5.0-alpha.0

package/dist/file/move-files.js

@@ -19,7 +19,7 @@ async function moveFiles(node, context, folder) {
         if (await context.file.exists(folder.to)) {
             await context.file.remove(folder.to);
         }
-        node.status.console.write('internal', 'debug', `copy ${folder.from} to ${folder.to}`);
+        context.status.task(node).write('debug', `copy ${folder.from} to ${folder.to}`);
         await context.file.copy(folder.from, folder.to);
     }
 }

package/dist/get-work-context.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkScope = void 0;
+const plan_work_tree_1 = require("./planner/utils/plan-work-tree");
+const plan_work_nodes_1 = require("./planner/utils/plan-work-nodes");
+const work_scope_1 = require("./executer/work-scope");
+const replace_env_variables_1 = require("./environment/replace-env-variables");
+const work_service_1 = require("./planner/work-service");
+const work_node_1 = require("./planner/work-node");
+const get_process_env_1 = require("./environment/get-process-env");
+function getWorkScope(buildFile, contextFilter, environment) {
+    const tree = (0, work_scope_1.isContextTaskFilter)(contextFilter)
+        ? (0, plan_work_tree_1.planWorkTree)(buildFile, { taskName: contextFilter.taskName })
+        : (0, plan_work_nodes_1.planWorkNodes)(buildFile, contextFilter);
+    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(tree.nodes)) {
+        node.envs = (0, replace_env_variables_1.replaceEnvVariables)(node.envs, environment.processEnvs);
+        if (!(0, work_node_1.isContainerWorkNode)(node)) {
+            node.envs = (0, get_process_env_1.extendHostVariables)(node.envs, environment);
+        }
+    }
+    for (const service of (0, plan_work_nodes_1.iterateWorkServices)(tree.services)) {
+        if ((0, work_service_1.isContainerWorkService)(service)) {
+            service.envs = (0, replace_env_variables_1.replaceEnvVariables)(service.envs, environment.processEnvs);
+        }
+    }
+    return tree;
+}
+exports.getWorkScope = getWorkScope;
+//# sourceMappingURL=get-work-context.js.map

package/dist/index.js

@@ -4,20 +4,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const program_1 = require("./program");
 const log_1 = require("./log");
 const get_file_context_1 = require("./file/get-file-context");
-const defer_1 = require("./utils/defer");
-const cancelDefer = new defer_1.Defer();
+const work_node_status_1 = require("./planner/work-node-status");
+const execute_docker_1 = require("./executer/execute-docker");
+const abortCtrl = new AbortController();
 process.on('SIGINT', function () {
-    if (!cancelDefer.isResolved) {
-        cancelDefer.resolve();
-    }
+    abortCtrl.abort();
 });
-program_1.getProgram({
+(0, program_1.getProgram)({
     cwd: process.cwd(),
-    cancelDefer,
+    abortCtrl,
     processEnvs: process.env,
-    file: get_file_context_1.getFileContext(),
-    console: log_1.consoleContext(),
+    file: (0, get_file_context_1.getFileContext)(process.cwd()),
+    console: (0, log_1.consoleContext)(),
+    status: (0, work_node_status_1.statusConsole)(),
+    docker: (0, execute_docker_1.getContainerCli)(),
 }, process.argv).then(({ program, args }) => {
-    program.parse(args);
+    return program.parseAsync(args);
 });
 //# sourceMappingURL=index.js.map

package/dist/log.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.showCursor = exports.hideCursor = exports.writeWorkTreeStatus = exports.getNodeName = exports.getNodeNameLength = exports.printWorkTreeResult = exports.isVerbose = exports.consoleContext = exports.getLogLevel = exports.getLogs = void 0;
+exports.showCursor = exports.hideCursor = exports.writeWorkTreeStatus = exports.formatDate = exports.writeNodeLogToConsole = exports.getNodeName = exports.getNodeNameLengthForWorkTree = exports.getNodeNameLength = exports.printTitle = exports.printItem = exports.printProperty = exports.getNodeNameLengthForSchedulerState = exports.printWorkTreeResult = exports.getType = exports.isVerbose = exports.consoleContext = exports.getErrorMessage = exports.getLogLevel = exports.getLogs = void 0;
 const readline_1 = require("readline");
 const plan_work_nodes_1 = require("./planner/utils/plan-work-nodes");
 const colors_1 = __importDefault(require("colors"));
+const fail_never_1 = require("./utils/fail-never");
 function getLogs(chunk) {
     return chunk
         .toString()
@@ -27,44 +28,88 @@ function getLogLevel(level) {
     }
 }
 exports.getLogLevel = getLogLevel;
+function getErrorMessage(e) {
+    if (e instanceof Error) {
+        return e.message;
+    }
+    else if (typeof e === 'string') {
+        return e;
+    }
+    else {
+        return `unknown error ${e}`;
+    }
+}
+exports.getErrorMessage = getErrorMessage;
 function consoleContext() {
     return {
         debug(message) {
-            process.stdout.write(`${getLogLevel('debug')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('debug')}: ${message}\n`);
         },
         error(message) {
-            process.stdout.write(`${getLogLevel('error')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('error')}: ${message}\n`);
         },
         info(message) {
-            process.stdout.write(`${getLogLevel('info')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('info')}: ${message}\n`);
         },
         warn(message) {
-            process.stdout.write(`${getLogLevel('warn')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('warn')}: ${message}\n`);
         },
     };
 }
 exports.consoleContext = consoleContext;
 exports.isVerbose = process.argv.some((a) => a === '--verbose');
-async function printWorkTreeResult(workTree, result, logConsoleOnFail) {
-    const maxNodeNameLength = getNodeNameLength(workTree);
-    if (logConsoleOnFail && (!result.success || exports.isVerbose)) {
-        for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-            if (node.status.state.type === 'failed' || exports.isVerbose) {
-                const logs = await node.status.console.read();
-                for (const log of logs) {
-                    if (log.level === 'debug' && !exports.isVerbose) {
-                        continue;
-                    }
-                    process.stdout.write(`${colors_1.default.grey('task:')} ${getNodeName(node, maxNodeNameLength)} ${getLogLevel(log.level)}: ${log.message}\n`);
-                }
-                process.stdout.write('-----------------\n');
+const typeLength = ['service', 'task', 'cli']
+    .map((s) => s.length)
+    .reduce((max, current) => (max > current ? max : current), 0);
+function getType(type) {
+    return colors_1.default.grey(getNodeName(type, typeLength) + ':');
+}
+exports.getType = getType;
+async function printWorkTreeResult(schedulerState, env) {
+    const maxNodeNameLength = getNodeNameLengthForSchedulerState(schedulerState);
+    for (const log of env.status.read()) {
+        if (exports.isVerbose || (log.type === 'status' && log.level === 'error')) {
+            process.stdout.write(`${formatDate(log.date)} ${getType(log.context.type)} ${getNodeName(log.context.name, maxNodeNameLength)} - ${colors_1.default.white(log.message)}\n`);
+        }
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+        if (state.type === 'end' && state.reason === 'crash') {
+            const message = `${getType('service')} ${getNodeName(state.service.name, maxNodeNameLength)}`;
+            for (const log of env.status.service(state.service).logs()) {
+                process.stdout.write(`${formatDate(log.date)} ${message} - ${log.console}: ${log.message}\n`);
+            }
+        }
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+        if (state.type === 'error' || state.type === 'crash') {
+            const message = `${getType('task')} ${getNodeName(state.node.name, maxNodeNameLength)}`;
+            for (const log of env.status.task(state.node).logs()) {
+                process.stdout.write(`${formatDate(log.date)} ${message} - ${log.console}: ${log.message}\n`);
+            }
+        }
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+        let message = `${formatDate(new Date())} ${getType('service')} ${getNodeName(state.service.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        if (state.type === 'end') {
+            if (state.reason === 'crash') {
+                message += ` crashed`;
             }
+            process.stdout.write(`${message}\n`);
         }
     }
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        let message = `${colors_1.default.grey('task:')} ${getNodeName(node, maxNodeNameLength)} - ${getStateText(node.status.state)}`;
-        if (node.status.state.type === 'completed') {
-            message += ` in ${node.status.state.duration}ms`;
+    for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+        let message = `${formatDate(new Date())} ${getType('task')} ${getNodeName(state.node.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        if (state.type === 'completed') {
+            message += ` in ${state.duration}ms`;
+            if (state.cached) {
+                message += ' [CACHED]';
+            }
+        }
+        if (state.type === 'crash') {
+            message += ` exited with ${state.exitCode}`;
+        }
+        if (state.type === 'error') {
+            message += ` with message ${state.errorMessage}`;
         }
         process.stdout.write(`${message}\n`);
     }
@@ -75,66 +120,178 @@ function getStateText(state) {
     if (state.type === 'running') {
         return colors_1.default.blue(state.type);
     }
-    else if (state.type === 'pending') {
+    else if (state.type === 'pending' || state.type === 'starting') {
         return colors_1.default.yellow(state.type);
     }
     else if (state.type === 'completed') {
         return colors_1.default.green(state.type);
     }
-    else if (state.type === 'failed') {
+    else if (state.type === 'crash') {
         return colors_1.default.red(state.type);
     }
-    else if (state.type === 'aborted') {
+    else if (state.type === 'error') {
         return colors_1.default.red(state.type);
     }
-    else if (state.type === 'cancel') {
+    else if (state.type === 'end') {
         return colors_1.default.bgRed(state.type);
     }
+    else if (state.type === 'canceled') {
+        return colors_1.default.bgRed(state.type);
+    }
+    else if (state.type === 'ready') {
+        return colors_1.default.blue(state.type);
+    }
     else {
-        //TODO fail never
-        return '';
+        (0, fail_never_1.failNever)(state, 'unknown node state');
+    }
+}
+function getNodeNameLengthForSchedulerState(schedulerState) {
+    function* Names() {
+        for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+            yield node.node.name;
+        }
+        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+            yield service.service.name;
+        }
     }
+    return getNodeNameLength(Names);
+}
+exports.getNodeNameLengthForSchedulerState = getNodeNameLengthForSchedulerState;
+function printProperty(name, value) {
+    process.stdout.write(`   ${colors_1.default.grey(`${name}:`)} ${value}\n`);
 }
-function getNodeNameLength(workTree) {
+exports.printProperty = printProperty;
+function printItem(item) {
+    process.stdout.write(`• ${item.name}${item.description ? `: ${colors_1.default.white(item.description)}` : ''}\n`);
+}
+exports.printItem = printItem;
+function printTitle(name) {
+    process.stdout.write(`${colors_1.default.bgWhite(name + ':\n')}`);
+}
+exports.printTitle = printTitle;
+function getNodeNameLength(names) {
     let maxNodeNameLength = 0;
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        if (node.name.length > maxNodeNameLength) {
-            maxNodeNameLength = node.name.length;
+    for (const name of names()) {
+        if (name.length > maxNodeNameLength) {
+            maxNodeNameLength = name.length;
         }
     }
     return maxNodeNameLength;
 }
 exports.getNodeNameLength = getNodeNameLength;
-function getNodeName(node, maxNodeNameLength) {
-    return colors_1.default.white(node.name) + ' '.repeat(maxNodeNameLength - node.name.length);
+function getNodeNameLengthForWorkTree(nodes, services) {
+    function* Names() {
+        for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(nodes)) {
+            yield node.node.name;
+        }
+        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(services)) {
+            yield service.service.name;
+        }
+    }
+    return getNodeNameLength(Names);
+}
+exports.getNodeNameLengthForWorkTree = getNodeNameLengthForWorkTree;
+function getNodeName(name, maxNodeNameLength) {
+    return colors_1.default.white(name) + ' '.repeat(Math.max(0, maxNodeNameLength - name.length));
 }
 exports.getNodeName = getNodeName;
-function writeWorkTreeStatus(workTree, ticker) {
-    readline_1.clearScreenDown(process.stdout);
-    const maxNodeNameLength = getNodeNameLength(workTree);
+function writeNodeLogToConsole(log, maxNodeNameLength) {
+    const content = log.type === 'console'
+        ? log.console === 'stdout'
+            ? colors_1.default.white(log.message)
+            : colors_1.default.red(log.message)
+        : `${getLogLevel(log.level)} - ${log.message}`;
+    process.stdout.write(`${formatDate(log.date)} ${colors_1.default.grey(log.context.type + ':')} ${getNodeName(log.context.name, maxNodeNameLength)} - ${log.date.toLocaleTimeString()} - ${content}\n`);
+}
+exports.writeNodeLogToConsole = writeNodeLogToConsole;
+function formatDate(date) {
+    return colors_1.default.grey(`[${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date
+        .getDay()
+        .toString()
+        .padStart(2, '0')} ${date.getHours().toString().padStart(2, '0')}:${date
+        .getMinutes()
+        .toString()
+        .padStart(2, '0')}:${date.getSeconds().toString().padStart(2, '0')}.${date
+        .getMilliseconds()
+        .toString()
+        .padStart(3, '0')}]`);
+}
+exports.formatDate = formatDate;
+function writeWorkTreeStatus(schedulerState, env, ticker) {
+    (0, readline_1.clearScreenDown)(process.stdout);
+    const maxNodeNameLength = getNodeNameLengthForSchedulerState(schedulerState);
     let count = 0;
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        const completedDepCount = Object.keys(node.status.completedDependencies).length;
-        const totalDepCount = completedDepCount + Object.keys(node.status.pendingDependencies).length;
-        let message = `${colors_1.default.grey('task:')} ${getNodeName(node, maxNodeNameLength)} - ${getStateText(node.status.state)}`;
-        if (totalDepCount > 0 && completedDepCount !== totalDepCount) {
-            message += ` | ${colors_1.default.grey(` awaiting dependencies (${completedDepCount}/${totalDepCount})`)}`;
-        }
-        if (node.status.state.type === 'running') {
+    for (const state of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+        let message = `${getType('service')} ${getNodeName(state.service.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        const currentMessage = env.status.service(state.service).current();
+        if (currentMessage) {
+            message += ` ${currentMessage.message}`;
+        }
+        count += printWithTruncate(message);
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+        let message = `${getType('task')} ${getNodeName(state.node.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        if (state.type === 'pending') {
+            const totalDepCount = state.node.deps.length;
+            const totalServiceCount = state.node.needs.length;
+            const completedDepCount = state.node.deps.filter((d) => schedulerState.node[d.id]?.type === 'completed').length;
+            const runningServiceCount = state.node.needs.filter((n) => schedulerState.service[n.id]?.type === 'ready').length;
+            if (totalDepCount > 0 && completedDepCount !== totalDepCount) {
+                message += ` | ${colors_1.default.grey(` awaiting dependencies (${completedDepCount}/${totalDepCount})`)}`;
+            }
+            if (totalServiceCount > 0 && runningServiceCount !== totalServiceCount) {
+                message += ` | ${colors_1.default.grey(` awaiting service (${runningServiceCount}/${totalServiceCount})`)}`;
+            }
+        }
+        if (state.type === 'starting' || state.type === 'ready') {
             message += ` | ${spinner[ticker % spinner.length]}`;
-            if (node.status.console.current) {
-                message += ` ${node.status.console.current.message}`;
+            const currentMessage = env.status.task(state.node).current();
+            if (currentMessage) {
+                message += ` ${currentMessage.message}`;
             }
         }
-        else if (node.status.state.type === 'completed') {
-            message += ` in ${node.status.state.duration}ms`;
+        else if (state.type === 'running') {
+            message += ` | ${spinner[ticker % spinner.length]}`;
+            const currentMessage = env.status.task(state.node).currentLog();
+            if (currentMessage) {
+                message += ` ${currentMessage.message}`;
+            }
         }
-        process.stdout.write(`${message}\n`);
-        count++;
+        else if (state.type === 'completed') {
+            message += ` in ${state.duration}ms`;
+            if (state.cached) {
+                message += ' [CACHED]';
+            }
+        }
+        else if (state.type === 'error') {
+            message += ` ${state.errorMessage}`;
+        }
+        count += printWithTruncate(message);
     }
-    readline_1.moveCursor(process.stdout, 0, -1 * count);
+    (0, readline_1.moveCursor)(process.stdout, 0, -1 * count);
 }
 exports.writeWorkTreeStatus = writeWorkTreeStatus;
+function countChar(message, char) {
+    let result = 0;
+    for (let i = 0; i < message.length; i++) {
+        if (message[i] === char) {
+            result++;
+        }
+    }
+    return result;
+}
+function printWithTruncate(message) {
+    let lineCount = 0;
+    let index = 0;
+    do {
+        const newLineCount = countChar(message, '\n');
+        process.stdout.write(`${message.substr(index, process.stdout.columns)}\n`);
+        index += process.stdout.columns;
+        lineCount++;
+        lineCount += newLineCount;
+    } while (index < message.length);
+    return lineCount;
+}
 function hideCursor() {
     process.stdout.write('\x1B[?25l');
 }

package/dist/logging/grouped-logger.js

@@ -2,26 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupedLogger = void 0;
 const log_1 = require("../log");
-const message_to_console_1 = require("./message-to-console");
-function groupedLogger() {
-    let maxNodeNameLength = 0;
-    return {
-        start(executionContext, workTree) {
-            maxNodeNameLength = log_1.getNodeNameLength(workTree);
-            executionContext.events.on(async (evt) => {
-                if (evt.newState.type === 'completed' || evt.newState.type === 'failed' || evt.newState.type === 'aborted') {
-                    const node = workTree.nodes[evt.nodeId];
-                    for (const log of await node.status.console.read()) {
-                        message_to_console_1.logMessageToConsole(node, log, maxNodeNameLength);
-                    }
+const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+function groupedLogger(state, env) {
+    const maxNodeNameLength = (0, log_1.getNodeNameLengthForWorkTree)(state.current.node, state.current.service);
+    const completedNodes = [];
+    const completedServices = [];
+    state.on((currentState) => {
+        for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(currentState.node)) {
+            if (completedNodes.indexOf(node.node.id) >= 0) {
+                continue;
+            }
+            if (node.type === 'crash' || node.type === 'error' || node.type === 'completed') {
+                completedNodes.push(node.node.id);
+                for (const log of env.status.task(node.node).read()) {
+                    (0, log_1.writeNodeLogToConsole)(log, maxNodeNameLength);
                 }
-            });
-        },
-        async finish(workTree, result) {
-            await log_1.printWorkTreeResult(workTree, result, false);
-        },
-        abort(e) {
-            process.stderr.write(`${e.message}\n`);
+            }
+        }
+        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(currentState.service)) {
+            if (completedServices.indexOf(service.service.id) >= 0) {
+                continue;
+            }
+            if (service.type === 'end') {
+                completedServices.push(service.service.id);
+                for (const log of env.status.service(service.service).read()) {
+                    (0, log_1.writeNodeLogToConsole)(log, maxNodeNameLength);
+                }
+            }
+        }
+    });
+    return {
+        async complete(evt, env) {
+            await (0, log_1.printWorkTreeResult)(evt.state, env);
         },
     };
 }

package/dist/logging/interactive-logger.js

@@ -3,33 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.interactiveLogger = void 0;
 const log_1 = require("../log");
 const readline_1 = require("readline");
-function interactiveLogger() {
+function interactiveLogger(state, env) {
     let running = true;
     let count = 0;
+    const tickerFn = () => {
+        if (!running) {
+            return;
+        }
+        count++;
+        (0, log_1.writeWorkTreeStatus)(state.current, env, count);
+        if (running) {
+            setTimeout(tickerFn, 100);
+        }
+    };
+    (0, log_1.hideCursor)();
+    tickerFn();
+    state.on((currentState) => {
+        (0, log_1.writeWorkTreeStatus)(currentState, env, count);
+    });
     return {
-        start(executionContext, workTree) {
-            log_1.hideCursor();
-            log_1.writeWorkTreeStatus(workTree, count);
-            const tickerFn = () => {
-                count++;
-                log_1.writeWorkTreeStatus(workTree, count);
-                if (running) {
-                    setTimeout(tickerFn, 100);
-                }
-            };
-            tickerFn();
-            executionContext.events.on(({ workTree }) => {
-                log_1.writeWorkTreeStatus(workTree, count);
-            });
-        },
-        async finish(workTree, result) {
+        async complete(evt, env) {
             running = false;
-            readline_1.clearScreenDown(process.stdout);
-            await log_1.printWorkTreeResult(workTree, result, true);
-            log_1.showCursor();
-        },
-        abort(e) {
-            process.stderr.write(`${e.message}\n`);
+            (0, readline_1.clearScreenDown)(process.stdout);
+            await (0, log_1.printWorkTreeResult)(evt.state, env);
+            (0, log_1.showCursor)();
         },
     };
 }

package/dist/logging/live-logger.js

@@ -2,24 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.liveLogger = void 0;
 const log_1 = require("../log");
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const message_to_console_1 = require("./message-to-console");
-function liveLogger() {
-    let maxNodeNameLength = 0;
+function liveLogger(state, env) {
+    const maxNodeNameLength = (0, log_1.getNodeNameLengthForWorkTree)(state.current.node, state.current.service);
+    env.status.on((log) => {
+        (0, log_1.writeNodeLogToConsole)(log, maxNodeNameLength);
+    });
     return {
-        start(executionContext, workTree) {
-            maxNodeNameLength = log_1.getNodeNameLength(workTree);
-            for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-                node.status.console.on((log) => {
-                    message_to_console_1.logMessageToConsole(node, log, maxNodeNameLength);
-                });
-            }
-        },
-        async finish(workTree, result) {
-            await log_1.printWorkTreeResult(workTree, result, false);
-        },
-        abort(e) {
-            process.stderr.write(`${e.message}\n`);
+        async complete(evt, env) {
+            await (0, log_1.printWorkTreeResult)(evt.state, env);
         },
     };
 }

package/dist/optimizer/calculate-checksum.js

@@ -4,7 +4,7 @@ exports.calculateChecksum = void 0;
 const crypto_1 = require("crypto");
 async function calculateChecksum(environment, path) {
     const input = await environment.file.read(path);
-    return crypto_1.createHash('sha1').update(input).digest('hex');
+    return (0, crypto_1.createHash)('sha1').update(input).digest('hex');
 }
 exports.calculateChecksum = calculateChecksum;
 //# sourceMappingURL=calculate-checksum.js.map

package/dist/optimizer/get-cache-directory.js

@@ -1,33 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHammerkitDirectory = exports.getCacheStatsFile = exports.getCacheStatsDirectory = exports.getCacheDescriptionFile = exports.getCacheDirectory = void 0;
+exports.getHammerkitDirectory = exports.getCacheStatsFile = exports.getCacheDescriptionFile = exports.getCacheDirectory = void 0;
 const path_1 = require("path");
-const crypto_1 = require("crypto");
 function getCacheDirectory(nodeId) {
-    return path_1.join(getHammerkitDirectory(), 'cache', nodeId);
+    return (0, path_1.join)(getHammerkitDirectory(), 'cache', nodeId);
 }
 exports.getCacheDirectory = getCacheDirectory;
 function getCacheDescriptionFile(nodeId) {
-    return path_1.join(getCacheDirectory(nodeId), 'description.json');
+    return (0, path_1.join)(getCacheDirectory(nodeId), 'description.json');
 }
 exports.getCacheDescriptionFile = getCacheDescriptionFile;
-function getCacheStatsDirectory(nodeId, cwd) {
-    return path_1.join(getCacheDirectory(nodeId), crypto_1.createHash('sha1').update(cwd).digest('hex'));
-}
-exports.getCacheStatsDirectory = getCacheStatsDirectory;
-function getCacheStatsFile(nodeId, cwd) {
-    return path_1.join(getCacheStatsDirectory(nodeId, cwd), 'stats.json');
+function getCacheStatsFile(nodeId) {
+    return (0, path_1.join)(getCacheDirectory(nodeId), 'stats.json');
 }
 exports.getCacheStatsFile = getCacheStatsFile;
 function getHammerkitDirectory() {
     if (process.platform === 'win32') {
-        return path_1.join(process.env.APPDATA, 'hammerkit');
+        return (0, path_1.join)(process.env.APPDATA, 'hammerkit');
     }
     else if (process.platform === 'darwin') {
-        return path_1.join(process.env.HOME, 'Library', 'Application Support', 'hammerkit');
+        return (0, path_1.join)(process.env.HOME, 'Library', 'Application Support', 'hammerkit');
     }
     else {
-        return path_1.join(process.env.HOME, '.hammerkit');
+        return (0, path_1.join)(process.env.HOME, '.hammerkit');
     }
 }
 exports.getHammerkitDirectory = getHammerkitDirectory;