hammerkit 1.5.0 → 1.6.0-alpha.1

package/dist/optimizer/get-work-cache-stats.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateKey = exports.getWorkCacheStats = void 0;
+const calculate_checksum_1 = require("./calculate-checksum");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+async function addWorkCacheStats(result, cwd, path, matcher, context) {
+    const exists = await context.file.exists(path);
+    if (!exists) {
+        return;
+    }
+    const stats = await context.file.stats(path);
+    if (stats.type === 'file') {
+        if (matcher(path)) {
+            const checksum = await (0, calculate_checksum_1.calculateChecksum)(context, path);
+            result.files[(0, path_1.relative)(cwd, path)] = { lastModified: stats.lastModified, checksum };
+        }
+    }
+    else if (stats.type === 'directory') {
+        const files = await context.file.listFiles(path);
+        for (const file of files) {
+            const subPath = (0, path_1.join)(path, file);
+            if (matcher(subPath)) {
+                await addWorkCacheStats(result, cwd, (0, path_1.join)(path, file), matcher, context);
+            }
+        }
+    }
+}
+async function getWorkCacheStats(work, environment) {
+    const result = {
+        created: new Date(),
+        files: {},
+    };
+    for (const src of work.src) {
+        await addWorkCacheStats(result, work.cwd, src.absolutePath, (file) => src.matcher(file, work.cwd), environment);
+    }
+    return result;
+}
+exports.getWorkCacheStats = getWorkCacheStats;
+function getStateKey(stats, cacheMethod) {
+    const contents = [];
+    for (const key of Object.keys(stats.files)) {
+        if (cacheMethod === 'checksum') {
+            contents.push(`${key}:${stats.files[key].checksum}`);
+        }
+        else if (cacheMethod === 'modify-date') {
+            contents.push(`${key}:${stats.files[key].lastModified}`);
+        }
+    }
+    return (0, crypto_1.createHash)('md5').update(contents.join(',')).digest('hex');
+}
+exports.getStateKey = getStateKey;
+//# sourceMappingURL=get-work-cache-stats.js.map

package/dist/optimizer/get-work-cache-stats.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const get_work_cache_stats_1 = require("./get-work-cache-stats");
+const environment_mock_1 = require("../executer/environment-mock");
+function stats(files) {
+    return { created: new Date(0), files };
+}
+describe('getStateKey', () => {
+    const sample = stats({
+        'a.txt': { lastModified: 1000, checksum: 'aaa' },
+        'b.txt': { lastModified: 2000, checksum: 'bbb' },
+    });
+    it('is deterministic for identical stats', () => {
+        expect((0, get_work_cache_stats_1.getStateKey)(sample, 'checksum')).toBe((0, get_work_cache_stats_1.getStateKey)(sample, 'checksum'));
+    });
+    it('produces different keys for checksum vs modify-date', () => {
+        expect((0, get_work_cache_stats_1.getStateKey)(sample, 'checksum')).not.toBe((0, get_work_cache_stats_1.getStateKey)(sample, 'modify-date'));
+    });
+    it('changes when a checksum changes (checksum method)', () => {
+        const changed = stats({
+            'a.txt': { lastModified: 1000, checksum: 'aaa' },
+            'b.txt': { lastModified: 2000, checksum: 'CHANGED' },
+        });
+        expect((0, get_work_cache_stats_1.getStateKey)(changed, 'checksum')).not.toBe((0, get_work_cache_stats_1.getStateKey)(sample, 'checksum'));
+    });
+    it('ignores checksum changes when using modify-date', () => {
+        const changed = stats({
+            'a.txt': { lastModified: 1000, checksum: 'aaa' },
+            'b.txt': { lastModified: 2000, checksum: 'CHANGED' },
+        });
+        expect((0, get_work_cache_stats_1.getStateKey)(changed, 'modify-date')).toBe((0, get_work_cache_stats_1.getStateKey)(sample, 'modify-date'));
+    });
+    it('returns a constant key for method "none" regardless of files', () => {
+        expect((0, get_work_cache_stats_1.getStateKey)(sample, 'none')).toBe((0, get_work_cache_stats_1.getStateKey)(stats({}), 'none'));
+    });
+});
+describe('getWorkCacheStats', () => {
+    let dir;
+    beforeEach(() => {
+        dir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-stats-'));
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(dir, { recursive: true, force: true });
+    });
+    function src(absolutePath, matcher = () => true) {
+        return { absolutePath, source: absolutePath, matcher };
+    }
+    it('returns empty files when src has no entries', async () => {
+        const env = (0, environment_mock_1.environmentMock)(dir);
+        const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)({ cwd: dir, src: [] }, env);
+        expect(stats.files).toEqual({});
+    });
+    it('skips a src path that does not exist (early return)', async () => {
+        const env = (0, environment_mock_1.environmentMock)(dir);
+        const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)({ cwd: dir, src: [src((0, path_1.join)(dir, 'missing'))] }, env);
+        expect(stats.files).toEqual({});
+    });
+    it('records a single file with checksum and lastModified', async () => {
+        (0, fs_1.writeFileSync)((0, path_1.join)(dir, 'a.txt'), 'hello');
+        const env = (0, environment_mock_1.environmentMock)(dir);
+        const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)({ cwd: dir, src: [src((0, path_1.join)(dir, 'a.txt'))] }, env);
+        expect(stats.files['a.txt']).toBeDefined();
+        expect(stats.files['a.txt'].checksum).toMatch(/^[0-9a-f]+$/);
+        expect(stats.files['a.txt'].lastModified).toBeGreaterThan(0);
+    });
+    it('walks a directory recursively and respects the matcher', async () => {
+        (0, fs_1.mkdirSync)((0, path_1.join)(dir, 'sub'));
+        (0, fs_1.writeFileSync)((0, path_1.join)(dir, 'sub', 'keep.txt'), 'k');
+        (0, fs_1.writeFileSync)((0, path_1.join)(dir, 'sub', 'skip.md'), 's');
+        const env = (0, environment_mock_1.environmentMock)(dir);
+        const stats = await (0, get_work_cache_stats_1.getWorkCacheStats)({ cwd: dir, src: [src((0, path_1.join)(dir, 'sub'), (file) => file.endsWith('.txt'))] }, env);
+        expect(Object.keys(stats.files)).toContain((0, path_1.join)('sub', 'keep.txt'));
+        expect(Object.keys(stats.files)).not.toContain((0, path_1.join)('sub', 'skip.md'));
+    });
+});
+//# sourceMappingURL=get-work-cache-stats.spec.js.map

package/dist/{parser/build-file-task.js → optimizer/work-cache-stats.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=build-file-task.js.map
+//# sourceMappingURL=work-cache-stats.js.map

package/dist/optimizer/work-task-cache-description.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkTaskCacheDescription = void 0;
+const os_1 = require("os");
+const replace_env_variables_1 = require("../environment/replace-env-variables");
+function getWorkTaskCacheDescription(task) {
+    const envs = (0, replace_env_variables_1.getEnvironmentVariables)(task.envs);
+    return {
+        shell: task.shell ?? undefined,
+        platform: task.type === 'container-task' ? task.image : (0, os_1.platform)(),
+        generates: task.generates.map((g) => g.path).sort() ?? undefined,
+        src: task.src.map((s) => s.source).sort() ?? undefined,
+        envs: Object.keys(envs)
+            .sort()
+            .reduce((map, key) => {
+            map[key] = envs[key];
+            return map;
+        }, {}) ?? undefined,
+        cmds: task.cmds.map((c) => ({ cmd: c.cmd, cwd: c.cwd })),
+        mounts: task.type === 'container-task' ? task.mounts.map((m) => m.mount).sort() : undefined,
+        cwd: task.cwd,
+    };
+}
+exports.getWorkTaskCacheDescription = getWorkTaskCacheDescription;
+//# sourceMappingURL=work-task-cache-description.js.map

package/dist/optimizer/work-task-cache-description.spec.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const work_task_cache_description_1 = require("./work-task-cache-description");
+const baseTask = {
+    name: 'build',
+    cwd: '/work',
+    description: null,
+    src: [{ source: 'b' }, { source: 'a' }],
+    generates: [{ path: 'out/b' }, { path: 'out/a' }],
+    envs: { variables: { B: '2', A: '1' }, replacements: [] },
+    cmds: [{ cwd: '/work', cmd: 'tsc' }],
+    scope: {},
+    labels: {},
+    shell: '/bin/sh',
+    caching: {},
+    continuous: false,
+};
+describe('getWorkTaskCacheDescription', () => {
+    it('describes a container task with image as platform and sorted mounts', () => {
+        const task = {
+            ...baseTask,
+            type: 'container-task',
+            image: 'node:alpine',
+            user: null,
+            mounts: [{ mount: 'b:b' }, { mount: 'a:a' }],
+        };
+        const d = (0, work_task_cache_description_1.getWorkTaskCacheDescription)(task);
+        expect(d.platform).toBe('node:alpine');
+        expect(d.mounts).toEqual(['a:a', 'b:b']);
+        expect(d.src).toEqual(['a', 'b']);
+        expect(d.generates).toEqual(['out/a', 'out/b']);
+        expect(Object.keys(d.envs)).toEqual(['A', 'B']); // sorted
+        expect(d.cmds).toEqual([{ cwd: '/work', cmd: 'tsc' }]);
+        expect(d.cwd).toBe('/work');
+        expect(d.shell).toBe('/bin/sh');
+    });
+    it('describes a local task with the host platform and no mounts', () => {
+        const task = { ...baseTask, type: 'local-task' };
+        const d = (0, work_task_cache_description_1.getWorkTaskCacheDescription)(task);
+        expect(d.platform).toBe((0, os_1.platform)());
+        expect(d.mounts).toBeUndefined();
+    });
+});
+//# sourceMappingURL=work-task-cache-description.spec.js.map

package/dist/parser/default-build-file.js

@@ -1,22 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultBuildFilename = void 0;
+exports.getBuildFilename = void 0;
 const path_1 = require("path");
-async function getDefaultBuildFilename(folder, env) {
+async function getBuildFilename(path, env) {
     const fileNames = ['.hammerkit.yaml', '.hammerkit.yml', 'build.yaml'];
+    const exists = await env.file.exists(path);
+    if (exists) {
+        const stats = await env.file.stats(path);
+        if (stats.type === 'file') {
+            return path;
+        }
+    }
     const existingFiles = [];
     for (const fileName of fileNames) {
-        if (await env.file.exists((0, path_1.join)(folder, fileName))) {
+        if (await env.file.exists((0, path_1.join)(path, fileName))) {
             existingFiles.push(fileName);
         }
     }
     if (existingFiles.length > 1) {
-        env.console.warn(`multiple hammerkit files ${existingFiles.join(', ')} in ${folder}`);
+        env.console.warn(`multiple hammerkit files ${existingFiles.join(', ')} in ${path}`);
     }
     if (existingFiles.length > 0) {
-        return existingFiles[0];
+        return (0, path_1.join)(path, existingFiles[0]);
     }
-    return fileNames[0];
+    return (0, path_1.join)(path, fileNames[0]);
 }
-exports.getDefaultBuildFilename = getDefaultBuildFilename;
+exports.getBuildFilename = getBuildFilename;
 //# sourceMappingURL=default-build-file.js.map

package/dist/parser/default-build-file.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const environment_mock_1 = require("../executer/environment-mock");
+const default_build_file_1 = require("./default-build-file");
+describe('getBuildFilename', () => {
+    let dir;
+    beforeEach(() => {
+        dir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-getbuildfilename-'));
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(dir, { recursive: true, force: true });
+    });
+    it('returns the path itself when it points at an existing file', async () => {
+        const file = (0, path_1.join)(dir, '.hammerkit.yaml');
+        (0, fs_1.writeFileSync)(file, 'tasks: {}\n');
+        expect(await (0, default_build_file_1.getBuildFilename)(file, (0, environment_mock_1.environmentMock)(dir))).toBe(file);
+    });
+    it('falls back to <dir>/.hammerkit.yaml when the directory has no build file', async () => {
+        expect(await (0, default_build_file_1.getBuildFilename)(dir, (0, environment_mock_1.environmentMock)(dir))).toBe((0, path_1.join)(dir, '.hammerkit.yaml'));
+    });
+    it('picks an existing build file in the directory', async () => {
+        (0, fs_1.writeFileSync)((0, path_1.join)(dir, 'build.yaml'), 'tasks: {}\n');
+        expect(await (0, default_build_file_1.getBuildFilename)(dir, (0, environment_mock_1.environmentMock)(dir))).toBe((0, path_1.join)(dir, 'build.yaml'));
+    });
+    it('prefers .hammerkit.yaml when multiple build files coexist and warns', async () => {
+        (0, fs_1.writeFileSync)((0, path_1.join)(dir, '.hammerkit.yaml'), 'tasks: {}\n');
+        (0, fs_1.writeFileSync)((0, path_1.join)(dir, 'build.yaml'), 'tasks: {}\n');
+        const env = (0, environment_mock_1.environmentMock)(dir);
+        const warn = vi.spyOn(env.console, 'warn').mockImplementation(() => undefined);
+        const result = await (0, default_build_file_1.getBuildFilename)(dir, env);
+        expect(result).toBe((0, path_1.join)(dir, '.hammerkit.yaml'));
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining('multiple hammerkit files'));
+    });
+    it('handles a missing path by returning <path>/.hammerkit.yaml', async () => {
+        const missing = (0, path_1.join)(dir, 'does-not-exist');
+        expect(await (0, default_build_file_1.getBuildFilename)(missing, (0, environment_mock_1.environmentMock)(dir))).toBe((0, path_1.join)(missing, '.hammerkit.yaml'));
+    });
+    it('ignores a path that exists but is neither a file nor a build dir match', async () => {
+        const sub = (0, path_1.join)(dir, 'sub');
+        (0, fs_1.mkdirSync)(sub);
+        // empty directory exists but has no build files; falls back to default
+        expect(await (0, default_build_file_1.getBuildFilename)(sub, (0, environment_mock_1.environmentMock)(dir))).toBe((0, path_1.join)(sub, '.hammerkit.yaml'));
+    });
+});
+//# sourceMappingURL=default-build-file.spec.js.map

package/dist/parser/parse-label-arguments.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_label_arguments_1 = require("./parse-label-arguments");
+describe('parse-label-arguments', () => {
+    it('parses a single key=value argument', () => {
+        expect((0, parse_label_arguments_1.parseLabelArguments)(['app=web'])).toEqual({ app: ['web'] });
+    });
+    it('collects multiple values for the same key', () => {
+        expect((0, parse_label_arguments_1.parseLabelArguments)(['app=web', 'app=api'])).toEqual({ app: ['web', 'api'] });
+    });
+    it('dedupes repeated values', () => {
+        expect((0, parse_label_arguments_1.parseLabelArguments)(['app=web', 'app=web'])).toEqual({ app: ['web'] });
+    });
+    it('keeps distinct keys separate', () => {
+        expect((0, parse_label_arguments_1.parseLabelArguments)(['app=web', 'tier=frontend'])).toEqual({ app: ['web'], tier: ['frontend'] });
+    });
+    it('returns an empty object for no arguments', () => {
+        expect((0, parse_label_arguments_1.parseLabelArguments)([])).toEqual({});
+    });
+    it('throws when an argument has no value', () => {
+        expect(() => (0, parse_label_arguments_1.parseLabelArguments)(['app'])).toThrow('invalid label app');
+    });
+    it('throws when an argument has multiple equals signs', () => {
+        expect(() => (0, parse_label_arguments_1.parseLabelArguments)(['app=web=extra'])).toThrow('invalid label app=web=extra');
+    });
+});
+//# sourceMappingURL=parse-label-arguments.spec.js.map

package/dist/parser/read-build-file.js

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readBuildFile = exports.read = exports.write = void 0;
+exports.read = exports.write = void 0;
 const yaml_1 = require("yaml");
-const parse_build_file_1 = require("./parse-build-file");
 async function write(filename, content, context) {
     await context.file.writeFile(filename, (0, yaml_1.stringify)(content));
 }
 exports.write = write;
 async function read(fileName, context) {
-    context.status
-        .context({ type: 'cli', id: 'general', name: 'hammerkit' })
-        .write('debug', `read ${fileName} build file`);
+    context.status.context({ type: 'cli', name: 'hammerkit' }).write('debug', `read ${fileName} build file`);
     let content;
     try {
         content = await context.file.read(fileName);
@@ -31,12 +28,4 @@ async function read(fileName, context) {
     }
 }
 exports.read = read;
-async function readBuildFile(fileName, files, context) {
-    if (files[fileName]) {
-        return files[fileName];
-    }
-    const input = await read(fileName, context);
-    return (0, parse_build_file_1.parseBuildFile)(fileName, files, input, context);
-}
-exports.readBuildFile = readBuildFile;
 //# sourceMappingURL=read-build-file.js.map

package/dist/parser/read-build-file.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const yaml = __importStar(require("yaml"));
+const environment_mock_1 = require("../executer/environment-mock");
+const read_build_file_1 = require("./read-build-file");
+// Re-export the real module through a plain (mutable) object so a single test can
+// spyOn parse. A true ESM namespace has non-configurable exports that vi.spyOn
+// cannot redefine; the spread keeps the real parse/stringify for every other test.
+vi.mock('yaml', async () => ({ ...(await vi.importActual('yaml')) }));
+describe('read-build-file', () => {
+    let scratch;
+    beforeEach(() => {
+        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-read-'));
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
+    });
+    describe('read', () => {
+        it('parses a yaml build file into an object', async () => {
+            const env = (0, environment_mock_1.environmentMock)(scratch);
+            const file = (0, path_1.join)(scratch, '.hammerkit.yaml');
+            (0, fs_1.writeFileSync)(file, 'tasks:\n  build:\n    cmds:\n      - echo hi\n');
+            const result = await (0, read_build_file_1.read)(file, env);
+            expect(result.tasks.build.cmds).toEqual(['echo hi']);
+        });
+        it('throws a readable error for a missing file', async () => {
+            const env = (0, environment_mock_1.environmentMock)(scratch);
+            await expect((0, read_build_file_1.read)((0, path_1.join)(scratch, 'does-not-exist.yaml'), env)).rejects.toThrow(/unable to read/);
+        });
+        it('throws a readable error for malformed yaml', async () => {
+            const env = (0, environment_mock_1.environmentMock)(scratch);
+            const file = (0, path_1.join)(scratch, '.hammerkit.yaml');
+            // tabs are not valid yaml indentation
+            (0, fs_1.writeFileSync)(file, 'tasks:\n\t- build\n');
+            await expect((0, read_build_file_1.read)(file, env)).rejects.toThrow(/unable to parse/);
+        });
+        it('rethrows non-Error throws from the yaml parser unchanged', async () => {
+            // Stub yaml.parse to throw a non-Error value so the `else throw e` branch
+            // in read() is exercised (the wrap-with-message branch only handles Error).
+            const spy = vi.spyOn(yaml, 'parse').mockImplementation(() => {
+                // eslint-disable-next-line @typescript-eslint/no-throw-literal
+                throw 'a plain string';
+            });
+            try {
+                const env = (0, environment_mock_1.environmentMock)(scratch);
+                const file = (0, path_1.join)(scratch, '.hammerkit.yaml');
+                (0, fs_1.writeFileSync)(file, 'x: 1\n');
+                await expect((0, read_build_file_1.read)(file, env)).rejects.toBe('a plain string');
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+    });
+    describe('write', () => {
+        it('serializes the value as yaml via the environment file context', async () => {
+            const env = (0, environment_mock_1.environmentMock)(scratch);
+            await (0, read_build_file_1.write)((0, path_1.join)(scratch, 'out.yaml'), { tasks: { hi: { cmds: ['echo hi'] } } }, env);
+            expect((0, fs_1.readFileSync)((0, path_1.join)(scratch, 'out.yaml'), 'utf8')).toMatch(/tasks:\n\s+hi:\n\s+cmds:\n\s+- echo hi/);
+        });
+    });
+});
+//# sourceMappingURL=read-build-file.spec.js.map

package/dist/parser/read-env-file.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEnvFile = void 0;
 const path_1 = require("path");
-async function readEnvFile(path, baseEnv, environment) {
+async function readEnvFile(path, environment, baseEnv = {}) {
     const directory = (0, path_1.join)(path, '.env');
     let envs = { ...baseEnv };
     if ((0, path_1.basename)(path) !== path) {
-        envs = { ...(await readEnvFile((0, path_1.basename)(path), envs, environment)) };
+        envs = { ...(await readEnvFile((0, path_1.basename)(path), environment, envs)) };
     }
     const exists = await environment.file.exists(directory);
     if (!exists) {
@@ -16,10 +16,9 @@ async function readEnvFile(path, baseEnv, environment) {
     for (const envVar of envFile) {
         const index = envVar.indexOf('=');
         if (index > 0) {
-            const key = envVar.substr(0, index);
-            const value = envVar.substr(index + 1);
+            const key = envVar.substring(0, index);
+            const value = envVar.substring(index + 1);
             if (!envs[key]) {
-                environment.console.debug(`load env variable ${key} from ${directory} file`);
                 envs[key] = value;
             }
         }

package/dist/parser/read-env-file.spec.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const read_env_file_1 = require("./read-env-file");
+// Build an Environment whose file context serves .env files from an in-memory map
+// keyed by directory. readEnvFile asks for `join(<dir>, '.env')`, so build the
+// keys the same way (native separators) — keeps the test correct on Windows too.
+function envWithFiles(dirs) {
+    const files = {};
+    for (const [dir, content] of Object.entries(dirs)) {
+        files[(0, path_1.join)(dir, '.env')] = content;
+    }
+    return {
+        file: {
+            exists: vi.fn(async (p) => p in files),
+            read: vi.fn(async (p) => files[p]),
+        },
+    };
+}
+describe('read-env-file', () => {
+    it('parses KEY=VALUE pairs from a .env file', async () => {
+        const env = envWithFiles({ proj: 'A=1\nB=2' });
+        expect(await (0, read_env_file_1.readEnvFile)('proj', env)).toEqual({ A: '1', B: '2' });
+    });
+    it('keeps "=" characters in the value and skips lines without "="', async () => {
+        const env = envWithFiles({ proj: 'URL=http://x?y=z\nNOEQ\n\nC=3' });
+        expect(await (0, read_env_file_1.readEnvFile)('proj', env)).toEqual({ URL: 'http://x?y=z', C: '3' });
+    });
+    it('does not overwrite values already present in baseEnv', async () => {
+        const env = envWithFiles({ proj: 'A=fromfile\nB=2' });
+        expect(await (0, read_env_file_1.readEnvFile)('proj', env, { A: 'base' })).toEqual({ A: 'base', B: '2' });
+    });
+    it('returns the base env when no .env file exists', async () => {
+        const env = envWithFiles({});
+        expect(await (0, read_env_file_1.readEnvFile)('proj', env, { X: 'y' })).toEqual({ X: 'y' });
+    });
+    it('reads the basename .env first, then the full path', async () => {
+        const env = envWithFiles({ b: 'FROM_B=1', 'a/b': 'FROM_AB=2' });
+        expect(await (0, read_env_file_1.readEnvFile)('a/b', env)).toEqual({ FROM_B: '1', FROM_AB: '2' });
+    });
+});
+//# sourceMappingURL=read-env-file.spec.js.map

package/dist/planner/utils/append-work-dependencies.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendWorkDependencies = void 0;
+const work_task_1 = require("../work-task");
+const work_service_1 = require("../work-service");
+const append_work_task_1 = require("./append-work-task");
+const label_values_1 = require("../../executer/label-values");
+function appendWorkDependencies(workTree, referenced, item, environment, context) {
+    for (const dep of referenced.deps) {
+        const depNode = (0, append_work_task_1.appendWorkTask)(workTree, dep.cwd, dep.task, environment, context);
+        item.deps.push(depNode);
+        item.data.labels = (0, label_values_1.mergeLabels)(item.data.labels, depNode.data.labels);
+        if ((0, work_task_1.isWorkTask)(item.data) || (0, work_service_1.isContainerWorkService)(item.data)) {
+            for (const src of depNode.data.src) {
+                if (!item.data.src.some((s) => s.absolutePath === src.absolutePath)) {
+                    item.data.src.push({ ...src, inherited: depNode });
+                }
+            }
+        }
+        if (((0, work_task_1.isContainerWorkTask)(depNode.data) || (0, work_service_1.isContainerWorkService)(depNode.data)) &&
+            ((0, work_task_1.isContainerWorkTask)(item.data) || (0, work_service_1.isContainerWorkService)(item.data))) {
+            for (const generate of depNode.data.generates) {
+                if (generate.isFile) {
+                    // TODO check if thats correct
+                    continue;
+                }
+                if (item.data.type === 'container-service') {
+                    if (!item.data.volumes.some((v) => v.name === generate.volumeName)) {
+                        item.data.volumes.push({
+                            name: generate.volumeName,
+                            export: false,
+                            resetOnChange: false,
+                            containerPath: generate.path,
+                            inherited: depNode,
+                        });
+                    }
+                }
+                else {
+                    if (!item.data.generates.some((v) => v.volumeName === generate.volumeName)) {
+                        item.data.generates.push({
+                            volumeName: generate.volumeName,
+                            export: false,
+                            resetOnChange: false,
+                            path: generate.path,
+                            inherited: depNode,
+                            isFile: false,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+exports.appendWorkDependencies = appendWorkDependencies;
+//# sourceMappingURL=append-work-dependencies.js.map

package/dist/planner/utils/append-work-environment.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendWorkEnvironment = void 0;
+function appendWorkEnvironment(referenced) {
+    if ('docker' in referenced.schema) {
+        return {
+            type: 'docker',
+            host: referenced.schema.docker.host,
+        };
+    }
+    else {
+        return {
+            type: 'kubernetes',
+            context: referenced.schema.kubernetes.context,
+            kubeConfig: referenced.schema.kubernetes.kubeconfig,
+            ingresses: referenced.schema.kubernetes.ingresses || [],
+            namespace: referenced.schema.kubernetes.namespace ?? 'default',
+        };
+    }
+}
+exports.appendWorkEnvironment = appendWorkEnvironment;
+//# sourceMappingURL=append-work-environment.js.map

package/dist/planner/utils/append-work-needs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendWorkNeeds = void 0;
+const append_work_service_1 = require("./append-work-service");
+function appendWorkNeeds(workTree, referenced, item, environment, context) {
+    for (const need of referenced.needs) {
+        const serviceNeed = (0, append_work_service_1.appendWorkService)(workTree, need.service, environment, context);
+        item.needs.push({
+            service: serviceNeed,
+            name: need.relativeName,
+        });
+        if (!serviceNeed.requiredBy.some((r) => r.name === item.name)) {
+            serviceNeed.requiredBy.push(item);
+        }
+    }
+}
+exports.appendWorkNeeds = appendWorkNeeds;
+//# sourceMappingURL=append-work-needs.js.map