hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/log.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const log_1 = require("./log");
+const environment_mock_1 = require("./executer/environment-mock");
+function capture() {
+    const chunks = [];
+    const stream = new stream_1.Writable({
+        write(chunk, _enc, cb) {
+            chunks.push(chunk.toString());
+            cb();
+        },
+    });
+    return { stream, read: () => chunks.join('') };
+}
+describe('log helpers', () => {
+    describe('getLogs', () => {
+        it('splits on \\r?\\n and drops empty lines', () => {
+            expect((0, log_1.getLogs)('a\r\nb\nc\n\n')).toEqual(['a', 'b', 'c']);
+        });
+        it('accepts a Buffer', () => {
+            expect((0, log_1.getLogs)(Buffer.from('x\ny'))).toEqual(['x', 'y']);
+        });
+    });
+    describe('getLogLevel', () => {
+        it.each(['debug', 'info', 'warn', 'error'])('returns a string containing %s', (level) => {
+            expect((0, log_1.getLogLevel)(level)).toContain(level);
+        });
+    });
+    describe('getErrorMessage', () => {
+        it('uses Error.message for Error instances', () => {
+            expect((0, log_1.getErrorMessage)(new Error('boom'))).toBe('boom');
+        });
+        it('returns a string value unchanged', () => {
+            expect((0, log_1.getErrorMessage)('plain')).toBe('plain');
+        });
+        it('falls back to "unknown error <value>" for other values', () => {
+            expect((0, log_1.getErrorMessage)({ x: 1 })).toMatch(/^unknown error/);
+        });
+    });
+    describe('consoleContext', () => {
+        it('writes formatted lines for each level', () => {
+            const cap = capture();
+            const ctx = (0, log_1.consoleContext)(cap.stream);
+            ctx.debug('d-msg');
+            ctx.info('i-msg');
+            ctx.warn('w-msg');
+            ctx.error('e-msg');
+            const out = cap.read();
+            expect(out).toContain('d-msg');
+            expect(out).toContain('i-msg');
+            expect(out).toContain('w-msg');
+            expect(out).toContain('e-msg');
+            // 4 newlines, one per call
+            expect(out.split('\n').filter((l) => l.length > 0)).toHaveLength(4);
+        });
+    });
+    describe('getType / getNodeName / getMaxNameLength', () => {
+        it('formats the type with the configured padding', () => {
+            expect((0, log_1.getType)('cli')).toContain('cli');
+        });
+        it('pads name to a given length', () => {
+            expect((0, log_1.getNodeName)('a', 4)).toContain('a');
+            // pads with spaces to reach the requested length, then color codes
+            // surround it — assert by inspecting the visible characters
+            // ANSI color wrappers can only add chars, so the rendered string is at
+            // least the requested width even when colors are enabled.
+            expect((0, log_1.getNodeName)('a', 4).length).toBeGreaterThanOrEqual(4);
+        });
+        it('getMaxNameLength returns the longest name yielded', () => {
+            const names = function* () {
+                yield 'aa';
+                yield 'aaaaa';
+                yield 'a';
+            };
+            expect((0, log_1.getMaxNameLength)(names)).toBe(5);
+        });
+        it('getMaxNameLength returns 0 for an empty source', () => {
+            expect((0, log_1.getMaxNameLength)(() => [])).toBe(0);
+        });
+    });
+    describe('print helpers', () => {
+        it('printItem with and without description', () => {
+            const env = (0, environment_mock_1.environmentMock)('/tmp');
+            const cap = capture();
+            env.stdout = cap.stream;
+            (0, log_1.printItem)(env, { name: 'a', description: null });
+            (0, log_1.printItem)(env, { name: 'b', description: 'desc' });
+            const out = cap.read();
+            expect(out).toContain('• a\n');
+            expect(out).toContain('• b');
+            expect(out).toContain('desc');
+        });
+        it('printProperty writes "<name>: <value>"', () => {
+            const env = (0, environment_mock_1.environmentMock)('/tmp');
+            const cap = capture();
+            env.stdout = cap.stream;
+            (0, log_1.printProperty)(env, 'image', 'alpine');
+            expect(cap.read()).toContain('image:');
+            expect(cap.read()).toContain('alpine');
+        });
+        it('printTitle writes the title with a colon', () => {
+            const env = (0, environment_mock_1.environmentMock)('/tmp');
+            const cap = capture();
+            env.stdout = cap.stream;
+            (0, log_1.printTitle)(env, 'Tasks');
+            expect(cap.read()).toContain('Tasks:');
+        });
+    });
+    describe('formatDate', () => {
+        it('produces a [yyyy-MM-DD HH:mm:ss.SSS] formatted timestamp', () => {
+            // Use a fixed Date in UTC; the function uses local-time getters, so only
+            // pattern-check the output rather than the literal value.
+            const out = (0, log_1.formatDate)(new Date(2024, 0, 2, 3, 4, 5, 6));
+            expect(out).toMatch(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]/);
+        });
+    });
+    describe('cursor', () => {
+        it('hideCursor / showCursor write escape sequences', () => {
+            const env = (0, environment_mock_1.environmentMock)('/tmp');
+            const cap = capture();
+            env.stdout = cap.stream;
+            (0, log_1.hideCursor)(env);
+            (0, log_1.showCursor)(env);
+            const out = cap.read();
+            expect(out).toContain('\x1B[?25l');
+            expect(out).toContain('\x1B[?25h');
+        });
+    });
+});
+//# sourceMappingURL=log.spec.js.map

package/dist/logging/grouped-logger.js

@@ -2,31 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupedLogger = void 0;
 const log_1 = require("../log");
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
 function groupedLogger(state, env) {
-    const maxNodeNameLength = (0, log_1.getNodeNameLengthForWorkTree)(state.current.node, state.current.service);
+    const maxNodeNameLength = (0, log_1.getWorkItemMaxLength)(state.current);
     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) {
+    state.on('log-status', (currentState) => {
+        for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(currentState)) {
+            if (completedNodes.indexOf(task.name) >= 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)(env, log, maxNodeNameLength);
+            if (task.state.current.type === 'crash' ||
+                task.state.current.type === 'error' ||
+                task.state.current.type === 'completed') {
+                completedNodes.push(task.name);
+                for (const log of task.status.read()) {
+                    (0, log_1.writeWorkItemLogToConsole)(env, log, maxNodeNameLength);
                 }
             }
         }
-        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(currentState.service)) {
-            if (completedServices.indexOf(service.service.id) >= 0) {
+        for (const service of (0, plan_work_tasks_1.iterateWorkServices)(currentState)) {
+            if (completedServices.indexOf(service.name) >= 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)(env, log, maxNodeNameLength);
+            if (service.state.current.type === 'end') {
+                completedServices.push(service.name);
+                for (const log of service.status.read()) {
+                    (0, log_1.writeWorkItemLogToConsole)(env, log, maxNodeNameLength);
                 }
             }
         }

package/dist/logging/grouped-logger.spec.js

@@ -0,0 +1,84 @@
+"use strict";
+// Verifies that the grouped logger only flushes a task/service once it reaches
+// a terminal state, by mocking the underlying log helpers and iterators.
+Object.defineProperty(exports, "__esModule", { value: true });
+vi.mock('../log', () => ({
+    writeWorkItemLogToConsole: vi.fn(),
+    printWorkTreeResult: vi.fn().mockResolvedValue(undefined),
+    getWorkItemMaxLength: vi.fn(() => 10),
+}));
+vi.mock('../planner/utils/plan-work-tasks', () => ({
+    iterateWorkTasks: vi.fn(),
+    iterateWorkServices: vi.fn(),
+}));
+const grouped_logger_1 = require("./grouped-logger");
+const state_1 = require("../executer/state");
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+const log_1 = require("../log");
+const mockedIterTasks = plan_work_tasks_1.iterateWorkTasks;
+const mockedIterServices = plan_work_tasks_1.iterateWorkServices;
+const mockedWrite = log_1.writeWorkItemLogToConsole;
+const mockedPrint = log_1.printWorkTreeResult;
+function fakeTask(name, type, logs = []) {
+    return { name, state: { current: { type } }, status: { read: () => logs } };
+}
+describe('groupedLogger', () => {
+    beforeEach(() => {
+        mockedWrite.mockClear();
+        mockedPrint.mockClear();
+        mockedIterTasks.mockReset();
+        mockedIterServices.mockReset();
+    });
+    it('flushes a task only once it reaches a terminal state and not again on re-emit', () => {
+        const t = fakeTask('t1', 'pending', [{ id: 1 }]);
+        mockedIterTasks.mockImplementation(function* () {
+            yield t;
+        });
+        mockedIterServices.mockImplementation(function* () { });
+        const state = new state_1.State({ services: {}, tasks: { t1: t } });
+        (0, grouped_logger_1.groupedLogger)(state, {});
+        state.set(state.current); // pending — should NOT flush
+        expect(mockedWrite).not.toHaveBeenCalled();
+        t.state.current.type = 'completed';
+        state.set(state.current); // completed — flush once
+        expect(mockedWrite).toHaveBeenCalledTimes(1);
+        state.set(state.current); // already-flushed task — must not flush again
+        expect(mockedWrite).toHaveBeenCalledTimes(1);
+    });
+    it.each(['crash', 'error', 'completed'])('flushes on terminal state %s', (terminal) => {
+        const t = fakeTask('t1', terminal, [{ id: 1 }]);
+        mockedIterTasks.mockImplementation(function* () {
+            yield t;
+        });
+        mockedIterServices.mockImplementation(function* () { });
+        const state = new state_1.State({ services: {}, tasks: { t1: t } });
+        (0, grouped_logger_1.groupedLogger)(state, {});
+        state.set(state.current);
+        expect(mockedWrite).toHaveBeenCalledTimes(1);
+    });
+    it('flushes a service on type "end" and not again', () => {
+        const s = fakeTask('svc1', 'starting', [{ id: 1 }]);
+        mockedIterTasks.mockImplementation(function* () { });
+        mockedIterServices.mockImplementation(function* () {
+            yield s;
+        });
+        const state = new state_1.State({ services: { svc1: s }, tasks: {} });
+        (0, grouped_logger_1.groupedLogger)(state, {});
+        state.set(state.current); // not yet ended
+        expect(mockedWrite).not.toHaveBeenCalled();
+        s.state.current.type = 'end';
+        state.set(state.current); // ended — flush
+        expect(mockedWrite).toHaveBeenCalledTimes(1);
+        state.set(state.current); // already flushed — no second call
+        expect(mockedWrite).toHaveBeenCalledTimes(1);
+    });
+    it('complete() delegates to printWorkTreeResult', async () => {
+        mockedIterTasks.mockImplementation(function* () { });
+        mockedIterServices.mockImplementation(function* () { });
+        const state = new state_1.State({ services: {}, tasks: {} });
+        const logger = (0, grouped_logger_1.groupedLogger)(state, {});
+        await logger.complete({ state: state.current, success: true }, {});
+        expect(mockedPrint).toHaveBeenCalledTimes(1);
+    });
+});
+//# sourceMappingURL=grouped-logger.spec.js.map

package/dist/logging/interactive-logger.js

@@ -18,7 +18,7 @@ function interactiveLogger(state, env) {
     };
     (0, log_1.hideCursor)(env);
     tickerFn();
-    state.on((currentState) => {
+    state.on('log-status', (currentState) => {
         (0, log_1.writeWorkTreeStatus)(currentState, env, count);
     });
     return {

package/dist/logging/interactive-logger.spec.js

@@ -0,0 +1,57 @@
+"use strict";
+// interactiveLogger hides the cursor, polls writeWorkTreeStatus on a 100ms
+// ticker, and writes on every state change until complete() stops it.
+Object.defineProperty(exports, "__esModule", { value: true });
+vi.mock('../log', () => ({
+    writeWorkTreeStatus: vi.fn(),
+    printWorkTreeResult: vi.fn().mockResolvedValue(undefined),
+    hideCursor: vi.fn(),
+    showCursor: vi.fn(),
+}));
+vi.mock('readline', () => ({ clearScreenDown: vi.fn() }));
+const interactive_logger_1 = require("./interactive-logger");
+const state_1 = require("../executer/state");
+const log_1 = require("../log");
+const readline_1 = require("readline");
+const mockedWriteStatus = log_1.writeWorkTreeStatus;
+const mockedHide = log_1.hideCursor;
+const mockedShow = log_1.showCursor;
+const mockedClear = readline_1.clearScreenDown;
+const mockedPrint = log_1.printWorkTreeResult;
+describe('interactiveLogger', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        mockedWriteStatus.mockClear();
+        mockedHide.mockClear();
+        mockedShow.mockClear();
+        mockedClear.mockClear();
+        mockedPrint.mockClear();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('hides the cursor, ticks every 100ms, and writes on state changes', async () => {
+        const state = new state_1.State({ services: {}, tasks: {} });
+        const env = { stdout: { write: vi.fn() } };
+        const logger = (0, interactive_logger_1.interactiveLogger)(state, env);
+        // hideCursor on construction; initial tick fired immediately
+        expect(mockedHide).toHaveBeenCalledTimes(1);
+        expect(mockedWriteStatus).toHaveBeenCalledTimes(1);
+        // advance one tick window → one additional writeWorkTreeStatus
+        vi.advanceTimersByTime(100);
+        expect(mockedWriteStatus).toHaveBeenCalledTimes(2);
+        // a state change writes status synchronously
+        state.set({ services: {}, tasks: {} });
+        expect(mockedWriteStatus).toHaveBeenCalledTimes(3);
+        // complete() stops the ticker and restores the cursor
+        await logger.complete({ state: state.current, success: true }, env);
+        expect(mockedClear).toHaveBeenCalledWith(env.stdout);
+        expect(mockedPrint).toHaveBeenCalledTimes(1);
+        expect(mockedShow).toHaveBeenCalledTimes(1);
+        // after complete, advancing time must NOT schedule further writes
+        const after = mockedWriteStatus.mock.calls.length;
+        vi.advanceTimersByTime(1000);
+        expect(mockedWriteStatus.mock.calls.length).toBe(after);
+    });
+});
+//# sourceMappingURL=interactive-logger.spec.js.map

package/dist/logging/live-logger.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.liveLogger = void 0;
 const log_1 = require("../log");
 function liveLogger(state, env) {
-    const maxNodeNameLength = (0, log_1.getNodeNameLengthForWorkTree)(state.current.node, state.current.service);
+    const maxNodeNameLength = (0, log_1.getWorkItemMaxLength)(state.current);
     env.status.on((log) => {
-        (0, log_1.writeNodeLogToConsole)(env, log, maxNodeNameLength);
+        (0, log_1.writeWorkItemLogToConsole)(env, log, maxNodeNameLength);
     });
     return {
         async complete(evt, env) {

package/dist/logging/live-logger.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+// liveLogger forwards every status message verbatim to writeWorkItemLogToConsole.
+Object.defineProperty(exports, "__esModule", { value: true });
+vi.mock('../log', () => ({
+    writeWorkItemLogToConsole: vi.fn(),
+    printWorkTreeResult: vi.fn().mockResolvedValue(undefined),
+    getWorkItemMaxLength: vi.fn(() => 10),
+}));
+const live_logger_1 = require("./live-logger");
+const state_1 = require("../executer/state");
+const log_1 = require("../log");
+const emitter_1 = require("../utils/emitter");
+const mockedWrite = log_1.writeWorkItemLogToConsole;
+const mockedPrint = log_1.printWorkTreeResult;
+describe('liveLogger', () => {
+    beforeEach(() => {
+        mockedWrite.mockClear();
+        mockedPrint.mockClear();
+    });
+    it('forwards each status message to writeWorkItemLogToConsole', () => {
+        const status = (0, emitter_1.emitter)();
+        const env = { status };
+        const state = new state_1.State({ services: {}, tasks: {} });
+        (0, live_logger_1.liveLogger)(state, env);
+        const msg = { type: 'status', message: 'hi' };
+        status.emit(msg);
+        expect(mockedWrite).toHaveBeenCalledWith(env, msg, 10);
+    });
+    it('complete() delegates to printWorkTreeResult', async () => {
+        const status = (0, emitter_1.emitter)();
+        const state = new state_1.State({ services: {}, tasks: {} });
+        const logger = (0, live_logger_1.liveLogger)(state, { status });
+        await logger.complete({ state: state.current, success: true }, {});
+        expect(mockedPrint).toHaveBeenCalledTimes(1);
+    });
+});
+//# sourceMappingURL=live-logger.spec.js.map

package/dist/logging/loggers.spec.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const state_1 = require("../executer/state");
+const work_item_status_1 = require("../planner/work-item-status");
+const live_logger_1 = require("./live-logger");
+const grouped_logger_1 = require("./grouped-logger");
+const interactive_logger_1 = require("./interactive-logger");
+function memStream() {
+    const chunks = [];
+    const stream = new stream_1.Writable({
+        write(c, _e, cb) {
+            chunks.push(c.toString());
+            cb();
+        },
+    });
+    return Object.assign(stream, { read: () => chunks.join('') });
+}
+function noopStream() {
+    return new stream_1.Writable({ write: (_c, _e, cb) => cb() });
+}
+function makeEnv(stdout = noopStream()) {
+    return {
+        cwd: '/tmp',
+        file: {},
+        processEnvs: {},
+        abortCtrl: new AbortController(),
+        console: { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn(), log: vi.fn() },
+        status: (0, work_item_status_1.statusConsole)(noopStream()),
+        stdout,
+        stderr: noopStream(),
+        stdoutColumns: 80,
+    };
+}
+function taskItem(env, name, state) {
+    const data = { type: 'local-task', name, description: null, scope: { fileName: 'x' } };
+    return {
+        id: () => name,
+        name,
+        data,
+        status: env.status.from(data),
+        state: new state_1.State(state),
+        needs: [],
+        deps: [],
+        requiredBy: [],
+        runtime: {},
+    };
+}
+function serviceItem(env, name, state) {
+    const data = { type: 'container-service', name, ports: [] };
+    return {
+        id: () => name,
+        name,
+        data,
+        status: env.status.from(data),
+        state: new state_1.State(state),
+        needs: [],
+        deps: [],
+        requiredBy: [],
+        runtime: {},
+    };
+}
+function workTree(items) {
+    return {
+        tasks: Object.fromEntries((items.tasks ?? []).map((t) => [t.name, t])),
+        services: Object.fromEntries((items.services ?? []).map((s) => [s.name, s])),
+        environment: { type: 'docker' },
+    };
+}
+describe('loggers', () => {
+    describe('liveLogger', () => {
+        it('writes each status message and renders results on complete', async () => {
+            const out = memStream();
+            const env = makeEnv(out);
+            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
+            const tree = workTree({ tasks: [task] });
+            const state = new state_1.State(tree);
+            const logger = (0, live_logger_1.liveLogger)(state, env);
+            // a write on the scoped console emits a message on env.status, which the
+            // logger's listener formats into env.stdout
+            task.status.write('info', 'compiling');
+            const result = { state: tree, success: true };
+            await logger.complete(result, env);
+            expect(out.read()).toContain('compiling');
+        });
+    });
+    describe('groupedLogger', () => {
+        it("writes a completed task's logs on the next status update", async () => {
+            const out = memStream();
+            const env = makeEnv(out);
+            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
+            const tree = workTree({ tasks: [task] });
+            const state = new state_1.State(tree);
+            const logger = (0, grouped_logger_1.groupedLogger)(state, env);
+            // buffer one info log, mark the task completed, then notify the parent state
+            task.status.write('info', 'compiling');
+            task.state.set({ type: 'completed', stateKey: 'k', duration: 5, cached: false });
+            state.set(tree);
+            await logger.complete({ state: tree, success: true }, env);
+            expect(out.read()).toContain('compiling');
+        });
+        it("writes an ended service's logs on the next status update", async () => {
+            const out = memStream();
+            const env = makeEnv(out);
+            const svc = serviceItem(env, 'db', { type: 'pending', stateKey: null });
+            const tree = workTree({ services: [svc] });
+            const state = new state_1.State(tree);
+            const logger = (0, grouped_logger_1.groupedLogger)(state, env);
+            svc.status.write('info', 'ready');
+            svc.state.set({ type: 'end', reason: 'terminated', stateKey: 'k' });
+            state.set(tree);
+            await logger.complete({ state: tree, success: true }, env);
+            expect(out.read()).toContain('ready');
+        });
+        it('does not duplicate a task that is already in the completed set', async () => {
+            const out = memStream();
+            const env = makeEnv(out);
+            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
+            const tree = workTree({ tasks: [task] });
+            const state = new state_1.State(tree);
+            const logger = (0, grouped_logger_1.groupedLogger)(state, env);
+            task.status.write('info', 'once');
+            task.state.set({ type: 'completed', stateKey: 'k', duration: 1, cached: false });
+            state.set(tree);
+            const after = out.read();
+            // a second notification with no further log message should not append another copy
+            state.set(tree);
+            expect(out.read()).toEqual(after);
+            await logger.complete({ state: tree, success: true }, env);
+        });
+    });
+    describe('interactiveLogger', () => {
+        beforeEach(() => vi.useFakeTimers());
+        afterEach(() => vi.useRealTimers());
+        it('hides the cursor, ticks, redraws on log-status, then cleans up on complete', async () => {
+            const out = memStream();
+            const env = makeEnv(out);
+            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
+            const tree = workTree({ tasks: [task] });
+            const state = new state_1.State(tree);
+            const logger = (0, interactive_logger_1.interactiveLogger)(state, env); // hideCursor + first tick + setTimeout
+            // drive a state change to re-render
+            task.state.set({ type: 'running', stateKey: 'k' });
+            state.set(tree);
+            // let one fake tick fire while running===true (covers the recursive branch)
+            vi.advanceTimersByTime(150);
+            await logger.complete({ state: tree, success: true }, env);
+            // and one more after complete — covers the `if (!running) return` early exit
+            vi.advanceTimersByTime(150);
+            expect(out.read().length).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=loggers.spec.js.map

package/dist/optimizer/calculate-checksum.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const environment_mock_1 = require("../executer/environment-mock");
+const calculate_checksum_1 = require("./calculate-checksum");
+describe('calculateChecksum', () => {
+    let scratch;
+    beforeEach(() => {
+        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-checksum-'));
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
+    });
+    it('returns the sha1 of the file contents', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const file = (0, path_1.join)(scratch, 'a.txt');
+        (0, fs_1.writeFileSync)(file, 'hello world');
+        const expected = (0, crypto_1.createHash)('sha1').update('hello world').digest('hex');
+        expect(await (0, calculate_checksum_1.calculateChecksum)(env, file)).toBe(expected);
+    });
+    it('is deterministic and content-sensitive', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const file = (0, path_1.join)(scratch, 'a.txt');
+        (0, fs_1.writeFileSync)(file, 'one');
+        const first = await (0, calculate_checksum_1.calculateChecksum)(env, file);
+        expect(await (0, calculate_checksum_1.calculateChecksum)(env, file)).toBe(first);
+        (0, fs_1.writeFileSync)(file, 'two');
+        expect(await (0, calculate_checksum_1.calculateChecksum)(env, file)).not.toBe(first);
+    });
+});
+//# sourceMappingURL=calculate-checksum.spec.js.map

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

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHammerkitDirectory = exports.getCacheStatsFile = exports.getCacheDescriptionFile = exports.getCacheDirectory = void 0;
 const path_1 = require("path");
-function getCacheDirectory(nodeId) {
-    return (0, path_1.join)(getHammerkitDirectory(), 'cache', nodeId);
+function getCacheDirectory(cacheId) {
+    return (0, path_1.join)(getHammerkitDirectory(), 'cache', cacheId);
 }
 exports.getCacheDirectory = getCacheDirectory;
-function getCacheDescriptionFile(nodeId) {
-    return (0, path_1.join)(getCacheDirectory(nodeId), 'description.json');
+function getCacheDescriptionFile(cacheId) {
+    return (0, path_1.join)(getCacheDirectory(cacheId), 'description.json');
 }
 exports.getCacheDescriptionFile = getCacheDescriptionFile;
-function getCacheStatsFile(nodeId) {
-    return (0, path_1.join)(getCacheDirectory(nodeId), 'stats.json');
+function getCacheStatsFile(cacheId) {
+    return (0, path_1.join)(getCacheDirectory(cacheId), 'stats.json');
 }
 exports.getCacheStatsFile = getCacheStatsFile;
 function getHammerkitDirectory() {

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const get_cache_directory_1 = require("./get-cache-directory");
+function withPlatform(value, env, fn) {
+    const originalPlatform = process.platform;
+    const originalEnv = {};
+    for (const k of Object.keys(env))
+        originalEnv[k] = process.env[k];
+    Object.defineProperty(process, 'platform', { value, configurable: true });
+    for (const [k, v] of Object.entries(env)) {
+        if (v === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = v;
+    }
+    try {
+        return fn();
+    }
+    finally {
+        Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        for (const [k, v] of Object.entries(originalEnv)) {
+            if (v === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = v;
+        }
+    }
+}
+describe('cache directory helpers', () => {
+    it('builds the per-cache directory under the hammerkit directory', () => {
+        const dir = (0, get_cache_directory_1.getCacheDirectory)('abc123');
+        expect(dir.endsWith((0, path_1.join)('cache', 'abc123'))).toBe(true);
+    });
+    it('builds the description file path under the cache directory', () => {
+        expect((0, get_cache_directory_1.getCacheDescriptionFile)('id').endsWith((0, path_1.join)('cache', 'id', 'description.json'))).toBe(true);
+    });
+    it('builds the stats file path under the cache directory', () => {
+        expect((0, get_cache_directory_1.getCacheStatsFile)('id').endsWith((0, path_1.join)('cache', 'id', 'stats.json'))).toBe(true);
+    });
+    describe('getHammerkitDirectory', () => {
+        it('uses %APPDATA% on Windows', () => {
+            withPlatform('win32', { APPDATA: 'C:\\Users\\X\\AppData\\Roaming' }, () => {
+                expect((0, get_cache_directory_1.getHammerkitDirectory)()).toBe((0, path_1.join)('C:\\Users\\X\\AppData\\Roaming', 'hammerkit'));
+            });
+        });
+        it('uses ~/Library/Application Support on macOS', () => {
+            withPlatform('darwin', { HOME: '/Users/x' }, () => {
+                expect((0, get_cache_directory_1.getHammerkitDirectory)()).toBe((0, path_1.join)('/Users/x', 'Library', 'Application Support', 'hammerkit'));
+            });
+        });
+        it('uses ~/.hammerkit on Linux', () => {
+            withPlatform('linux', { HOME: '/home/x' }, () => {
+                expect((0, get_cache_directory_1.getHammerkitDirectory)()).toBe((0, path_1.join)('/home/x', '.hammerkit'));
+            });
+        });
+    });
+});
+//# sourceMappingURL=get-cache-directory.spec.js.map