hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/schema/reference-parser.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findService = exports.findTask = exports.parseReferences = void 0;
+const build_file_task_schema_1 = require("./build-file-task-schema");
+const build_file_service_schema_1 = require("./build-file-service-schema");
+const split_name_1 = require("../planner/utils/split-name");
+const read_env_file_1 = require("../parser/read-env-file");
+const label_values_1 = require("../executer/label-values");
+const merge_environment_variables_1 = require("../environment/merge-environment-variables");
+const resolve_cache_1 = require("../cache/resolve-cache");
+function combinePath(namePrefix, name) {
+    return namePrefix.length > 0 ? `${namePrefix}:${name}` : name;
+}
+async function parseReferences(ctx, mainScope, environment) {
+    const declaredCaches = {};
+    const reference = {
+        files: {},
+        tasks: {},
+        services: {},
+        envFiles: {},
+        environments: {},
+        caches: {},
+    };
+    for (const file of Object.values(ctx.files)) {
+        if (!reference.envFiles[file.cwd]) {
+            reference.envFiles[file.cwd] = await (0, read_env_file_1.readEnvFile)(file.cwd, environment);
+        }
+        const buildFileEnvs = file.schema.envs;
+        if (file.schema.tasks) {
+            for (const [taskName, task] of Object.entries(file.schema.tasks)) {
+                const taskEnvs = (0, merge_environment_variables_1.mergeEnvironmentVariables)(task.envs, buildFileEnvs);
+                const relativeName = combinePath(file.namePrefix, taskName);
+                reference.tasks[relativeName] = {
+                    type: 'task',
+                    schema: task,
+                    cwd: file.cwd,
+                    relativeName,
+                    labels: (0, label_values_1.mergeLabels)(file.schema.labels, task.labels),
+                    envs: taskEnvs,
+                    scope: file,
+                    needs: [],
+                    deps: [],
+                };
+            }
+        }
+        if (file.schema.environments) {
+            for (const [envName, env] of Object.entries(file.schema.environments)) {
+                reference.environments[envName] = {
+                    type: 'environment',
+                    schema: env,
+                    scope: file,
+                    name: envName,
+                };
+            }
+        }
+        if (file.schema.caches) {
+            for (const [cacheName, cache] of Object.entries(file.schema.caches)) {
+                declaredCaches[cacheName] = cache;
+            }
+        }
+        if (file.schema.services) {
+            for (const [serviceName, service] of Object.entries(file.schema.services)) {
+                const relativeName = combinePath(file.namePrefix, serviceName);
+                const serviceEnvs = (0, merge_environment_variables_1.mergeEnvironmentVariables)((0, build_file_service_schema_1.isBuildFileKubernetesServiceSchema)(service) ? {} : service.envs, buildFileEnvs);
+                reference.services[relativeName] = {
+                    type: 'service',
+                    schema: service,
+                    cwd: file.cwd,
+                    relativeName,
+                    labels: (0, label_values_1.mergeLabels)(file.schema.labels, service.labels),
+                    scope: file,
+                    needs: [],
+                    deps: [],
+                    envs: serviceEnvs,
+                };
+            }
+        }
+    }
+    for (const task of Object.values(reference.tasks)) {
+        applySchemaExtension(reference, task);
+        resolveDeps(reference, task, task.scope, task.schema);
+        resolveNeeds(reference, task, task.scope, task.schema);
+    }
+    for (const service of Object.values(reference.services)) {
+        resolveDeps(reference, service, service.scope, service.schema);
+        resolveNeeds(reference, service, service.scope, service.schema);
+    }
+    reference.caches = (0, resolve_cache_1.withBuiltinCaches)(declaredCaches);
+    return reference;
+}
+exports.parseReferences = parseReferences;
+function applySchemaExtension(reference, task) {
+    if (!task.schema.extend) {
+        return;
+    }
+    const extend = findTask(reference, task.scope, task.schema.extend, null).task;
+    applySchemaExtension(reference, extend);
+    task.schema.shell = task.schema.shell ?? extend.schema.shell;
+    task.schema.cache = task.schema.cache ?? extend.schema.cache;
+    task.schema.cmds = extendArray(task.schema.cmds, extend.schema.cmds);
+    task.schema.src = extendArray(task.schema.src, extend.schema.src);
+    task.schema.generates = extendArray(task.schema.generates, extend.schema.generates);
+    task.schema.labels = extendObject(task.schema.labels, extend.schema.labels);
+    task.envs = (0, merge_environment_variables_1.mergeEnvironmentVariables)(task.envs, extend.schema.envs);
+    if ((0, build_file_task_schema_1.isBuildFileContainerTaskSchema)(extend.schema)) {
+        const taskSchema = task.schema;
+        taskSchema.image = taskSchema.image ?? extend.schema.image;
+        taskSchema.mounts = extendArray(taskSchema.mounts, extend.schema.mounts);
+    }
+    resolveNeeds(reference, task, extend.scope, extend.schema);
+    resolveDeps(reference, task, extend.scope, extend.schema);
+}
+function extendArray(base, extend) {
+    if (!extend) {
+        return base;
+    }
+    if (!base) {
+        return [...extend];
+    }
+    return [...extend, ...base];
+}
+function extendObject(base, extend) {
+    if (!extend) {
+        return base;
+    }
+    if (!base) {
+        return { ...extend };
+    }
+    return { ...extend, ...base };
+}
+function resolveDeps(reference, taskOrService, scope, schema) {
+    for (const depName of schema.deps || []) {
+        const depTask = findTask(reference, scope, depName, null);
+        taskOrService.deps.push({
+            task: depTask.task,
+            type: depTask.type,
+            cwd: depTask.type === 'include' ? taskOrService.cwd : depTask.task.cwd,
+            relativeName: depName,
+        });
+    }
+}
+function resolveNeeds(reference, taskOrService, scope, schema) {
+    if ((0, build_file_service_schema_1.isBuildFileKubernetesServiceSchema)(schema)) {
+        return;
+    }
+    for (const needName of schema.needs || []) {
+        if (typeof needName === 'string') {
+            taskOrService.needs.push({
+                relativeName: needName,
+                service: findService(reference, scope, needName),
+            });
+        }
+        else {
+            taskOrService.needs.push({
+                relativeName: needName.name,
+                service: findService(reference, scope, needName.service),
+            });
+        }
+    }
+}
+function findTask(ctx, scope, name, type) {
+    const ref = (0, split_name_1.splitName)(name);
+    if (ref.prefix) {
+        if (scope.references[ref.prefix]) {
+            return findTask(ctx, scope.references[ref.prefix].scope, ref.name, scope.references[ref.prefix].type);
+        }
+        else if (scope.schema.tasks && scope.schema.tasks[name]) {
+            return resolveTask(ctx, scope, name, type ?? 'build-file');
+        }
+    }
+    else if (scope.schema.tasks && scope.schema.tasks[ref.name]) {
+        return resolveTask(ctx, scope, ref.name, type ?? 'build-file');
+    }
+    throw new Error('unable to find ' + name); // TODO improve
+}
+exports.findTask = findTask;
+function resolveTask(ctx, scope, name, type) {
+    const fullName = combinePath(scope.namePrefix, name);
+    const buildFileTask = ctx.tasks[fullName];
+    if (!buildFileTask) {
+        throw new Error('unable to find ' + fullName);
+    }
+    return { task: buildFileTask, type };
+}
+function findService(ctx, scope, name) {
+    const ref = (0, split_name_1.splitName)(name);
+    if (ref.prefix) {
+        if (scope.references[ref.prefix]) {
+            return findService(ctx, scope.references[ref.prefix].scope, ref.name);
+        }
+        else if (scope.schema.services && scope.schema.services[name]) {
+            return resolveService(ctx, scope, name);
+        }
+    }
+    else if (scope.schema.services && scope.schema.services[ref.name]) {
+        return resolveService(ctx, scope, name);
+    }
+    throw new Error('unable to find ' + name); // TODO improve
+}
+exports.findService = findService;
+function resolveService(ctx, scope, name) {
+    const fullName = combinePath(scope.namePrefix, name);
+    const service = ctx.services[fullName];
+    if (!service) {
+        throw new Error('unable to find ' + fullName);
+    }
+    return service;
+}
+//# sourceMappingURL=reference-parser.js.map

package/dist/schema/reference-parser.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("../testing/test-case");
+const program_1 = require("../program");
+const path_1 = require("path");
+// Drive the full parse pipeline (schema-parser -> parseReferences -> getWorkContext)
+// over an in-memory build file and assert on the resulting work tree. This exercises
+// reference resolution: deps, needs, label merging and schema `extend`.
+async function withCli(buildFile, scope, fn) {
+    const testCase = (0, test_case_1.createTestCase)('reference-parser', { '.hammerkit.yaml': buildFile });
+    await testCase.setup(async (cwd, environment) => {
+        const cli = await (0, program_1.createCli)((0, path_1.join)(cwd, '.hammerkit.yaml'), environment, scope);
+        await fn(cli);
+    });
+}
+describe('reference-parser', () => {
+    it('resolves task dependencies', async () => {
+        await withCli({
+            tasks: {
+                install: { cmds: ['npm install'] },
+                build: { cmds: ['tsc'], deps: ['install'] },
+            },
+        }, { taskName: 'build' }, (cli) => {
+            const build = cli.task('build');
+            expect(build.deps.map((d) => d.name)).toEqual(['install']);
+        });
+    });
+    it('resolves service needs', async () => {
+        await withCli({
+            services: {
+                api: { image: 'nginx', ports: [] },
+            },
+            tasks: {
+                build: { cmds: ['tsc'], needs: ['api'] },
+            },
+        }, { taskName: 'build' }, (cli) => {
+            const build = cli.task('build');
+            expect(build.needs.map((n) => n.service.name)).toEqual(['api']);
+        });
+    });
+    it('merges build-file labels with task labels', async () => {
+        await withCli({
+            labels: { app: 'web' },
+            tasks: {
+                build: { cmds: ['tsc'], labels: { tier: 'backend' } },
+            },
+        }, { taskName: 'build' }, (cli) => {
+            expect(cli.task('build').data.labels).toEqual({ app: ['web'], tier: ['backend'] });
+        });
+    });
+    it('applies schema extend (image, cmds, labels)', async () => {
+        await withCli({
+            tasks: {
+                base: { image: 'node', cmds: ['a'] },
+                child: { extend: 'base', cmds: ['b'] },
+            },
+        }, { taskName: 'child' }, (cli) => {
+            const child = cli.task('child').data;
+            // child inherits the base image and is therefore a container task
+            expect(child.type).toBe('container-task');
+            expect(child.image).toBe('node');
+            // extendArray prepends the extended task's cmds before the child's own
+            expect(child.cmds).toHaveLength(2);
+        });
+    });
+    it('throws when a dependency cannot be found', async () => {
+        const testCase = (0, test_case_1.createTestCase)('reference-parser', {
+            '.hammerkit.yaml': { tasks: { build: { cmds: ['tsc'], deps: ['missing'] } } },
+        });
+        await testCase.setup(async (cwd, environment) => {
+            await expect((0, program_1.createCli)((0, path_1.join)(cwd, '.hammerkit.yaml'), environment, { taskName: 'build' })).rejects.toThrow('unable to find missing');
+        });
+    });
+    it('throws when a needed service cannot be found', async () => {
+        const testCase = (0, test_case_1.createTestCase)('reference-parser', {
+            '.hammerkit.yaml': { tasks: { build: { cmds: ['tsc'], needs: ['missingsvc'] } } },
+        });
+        await testCase.setup(async (cwd, environment) => {
+            await expect((0, program_1.createCli)((0, path_1.join)(cwd, '.hammerkit.yaml'), environment, { taskName: 'build' })).rejects.toThrow('unable to find missingsvc');
+        });
+    });
+});
+//# sourceMappingURL=reference-parser.spec.js.map

package/dist/schema/schema-parser.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendBuildFile = exports.createParseContext = void 0;
+const build_file_schema_1 = require("./build-file-schema");
+const read_build_file_1 = require("../parser/read-build-file");
+const path_1 = require("path");
+const default_build_file_1 = require("../parser/default-build-file");
+const parse_error_1 = require("./parse-error");
+async function createParseContext(fileName, environment) {
+    const ctx = {
+        files: {},
+    };
+    const scope = await appendBuildFile((0, path_1.dirname)(fileName), ctx, environment, fileName, []);
+    return { ctx, scope };
+}
+exports.createParseContext = createParseContext;
+async function appendBuildFile(cwd, ctx, environment, fileName, namePrefix) {
+    const relativeName = namePrefix.join(':');
+    const key = `${cwd}:${fileName}`;
+    if (ctx.files[key]) {
+        return ctx.files[key];
+    }
+    const input = await (0, read_build_file_1.read)(fileName, environment);
+    const result = await build_file_schema_1.buildFileSchema.safeParseAsync(input);
+    if (result.success) {
+        const scope = {
+            fileName,
+            cwd,
+            schema: result.data,
+            namePrefix: relativeName,
+            references: {},
+        };
+        ctx.files[key] = scope;
+        if (scope.schema.references) {
+            for (const referenceName of Object.keys(scope.schema.references)) {
+                const reference = scope.schema.references[referenceName];
+                const referenceFilename = await (0, default_build_file_1.getBuildFilename)((0, path_1.join)(scope.cwd, reference), environment);
+                const referenceScope = await appendBuildFile((0, path_1.dirname)(referenceFilename), ctx, environment, referenceFilename, [
+                    ...namePrefix,
+                    referenceName,
+                ]);
+                if (scope.references[referenceName]) {
+                    throw new Error(referenceName + ' already exists');
+                }
+                scope.references[referenceName] = { type: 'reference', scope: referenceScope };
+            }
+        }
+        if (scope.schema.includes) {
+            for (const includeName of Object.keys(scope.schema.includes)) {
+                const include = scope.schema.includes[includeName];
+                const includeFilename = await (0, default_build_file_1.getBuildFilename)((0, path_1.join)((0, path_1.dirname)(scope.fileName), include), environment);
+                const includeScope = await appendBuildFile(cwd, ctx, environment, includeFilename, [...namePrefix, includeName]);
+                if (scope.references[includeName]) {
+                    throw new Error(includeName + ' already exists');
+                }
+                scope.references[includeName] = { type: 'include', scope: includeScope };
+            }
+        }
+        return scope;
+    }
+    else {
+        throw new parse_error_1.ParseError(result.error, fileName);
+    }
+}
+exports.appendBuildFile = appendBuildFile;
+//# sourceMappingURL=schema-parser.js.map

package/dist/schema/schema-parser.spec.js

@@ -0,0 +1,80 @@
+"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 schema_parser_1 = require("./schema-parser");
+const parse_error_1 = require("./parse-error");
+describe('createParseContext', () => {
+    let scratch;
+    beforeEach(() => {
+        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-schema-'));
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
+    });
+    function writeBuildFile(content) {
+        const file = (0, path_1.join)(scratch, '.hammerkit.yaml');
+        (0, fs_1.writeFileSync)(file, content);
+        return file;
+    }
+    it('parses a valid build file', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const file = writeBuildFile('tasks:\n  build:\n    cmds:\n      - echo hi\n');
+        const { scope } = await (0, schema_parser_1.createParseContext)(file, env);
+        expect(scope.schema.tasks?.build).toBeDefined();
+    });
+    it('rejects an unknown top-level key (strict schema)', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const file = writeBuildFile('bogus: true\ntasks:\n  build:\n    cmds:\n      - echo hi\n');
+        await expect((0, schema_parser_1.createParseContext)(file, env)).rejects.toBeInstanceOf(parse_error_1.ParseError);
+    });
+    it('rejects a task with an invalid command shape', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const file = writeBuildFile('tasks:\n  build:\n    cmds: 42\n');
+        await expect((0, schema_parser_1.createParseContext)(file, env)).rejects.toBeInstanceOf(parse_error_1.ParseError);
+    });
+    it('resolves a reference to another build file', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const sub = (0, path_1.join)(scratch, 'sub');
+        (0, fs_1.writeFileSync)((0, path_1.join)(scratch, '.hammerkit.yaml'), 'references:\n  lib: sub\ntasks:\n  build:\n    cmds:\n      - echo root\n');
+        // create the referenced build file
+        (0, fs_1.mkdirSync)(sub);
+        (0, fs_1.writeFileSync)((0, path_1.join)(sub, '.hammerkit.yaml'), 'tasks:\n  lib-build:\n    cmds:\n      - echo lib\n');
+        const { scope } = await (0, schema_parser_1.createParseContext)((0, path_1.join)(scratch, '.hammerkit.yaml'), env);
+        expect(scope.references['lib']).toBeDefined();
+        expect(scope.references['lib'].scope.schema.tasks?.['lib-build']).toBeDefined();
+    });
+    it('resolves an include (sibling build file merged under a name)', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        (0, fs_1.writeFileSync)((0, path_1.join)(scratch, 'common.yaml'), 'tasks:\n  shared:\n    cmds:\n      - echo s\n');
+        (0, fs_1.writeFileSync)((0, path_1.join)(scratch, '.hammerkit.yaml'), 'includes:\n  npm: common.yaml\n');
+        const { scope } = await (0, schema_parser_1.createParseContext)((0, path_1.join)(scratch, '.hammerkit.yaml'), env);
+        expect(scope.references['npm']).toBeDefined();
+        expect(scope.references['npm'].type).toBe('include');
+        expect(scope.references['npm'].scope.schema.tasks?.['shared']).toBeDefined();
+    });
+    it('throws when an include and a reference share the same name', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const sub = (0, path_1.join)(scratch, 'sub');
+        (0, fs_1.mkdirSync)(sub);
+        (0, fs_1.writeFileSync)((0, path_1.join)(sub, '.hammerkit.yaml'), 'tasks:\n  x:\n    cmds:\n      - echo x\n');
+        (0, fs_1.writeFileSync)((0, path_1.join)(scratch, 'inc.yaml'), 'tasks:\n  y:\n    cmds:\n      - echo y\n');
+        (0, fs_1.writeFileSync)((0, path_1.join)(scratch, '.hammerkit.yaml'), 'references:\n  lib: sub\nincludes:\n  lib: inc.yaml\n');
+        await expect((0, schema_parser_1.createParseContext)((0, path_1.join)(scratch, '.hammerkit.yaml'), env)).rejects.toThrow(/lib already exists/);
+    });
+    it('reuses an already-parsed build file when reached again (cache hit)', async () => {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const sub = (0, path_1.join)(scratch, 'sub');
+        (0, fs_1.mkdirSync)(sub);
+        (0, fs_1.writeFileSync)((0, path_1.join)(sub, '.hammerkit.yaml'), 'tasks:\n  s:\n    cmds:\n      - echo s\n');
+        (0, fs_1.writeFileSync)((0, path_1.join)(scratch, '.hammerkit.yaml'), 'references:\n  a: sub\n  b: sub\n');
+        const { ctx, scope } = await (0, schema_parser_1.createParseContext)((0, path_1.join)(scratch, '.hammerkit.yaml'), env);
+        // Both references point at sub/.hammerkit.yaml and must end up at the same
+        // parsed ParseScope (the second appendBuildFile hits the ctx.files cache).
+        expect(scope.references['a'].scope).toBe(scope.references['b'].scope);
+        expect(Object.keys(ctx.files)).toHaveLength(2); // root + sub (sub cached on second visit)
+    });
+});
+//# sourceMappingURL=schema-parser.spec.js.map

package/dist/schema/type-guards.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const build_file_service_schema_1 = require("./build-file-service-schema");
+const build_file_task_schema_1 = require("./build-file-task-schema");
+describe('service/task type guards', () => {
+    it('isBuildFileContainerSchema discriminates by `image` presence', () => {
+        expect((0, build_file_service_schema_1.isBuildFileContainerSchema)({ image: 'node' })).toBe(true);
+        expect((0, build_file_service_schema_1.isBuildFileContainerSchema)({ selector: { name: 'n', type: 't' } })).toBe(false);
+    });
+    it('isBuildFileKubernetesServiceSchema discriminates by `selector` presence', () => {
+        expect((0, build_file_service_schema_1.isBuildFileKubernetesServiceSchema)({ selector: { name: 'n', type: 't' } })).toBe(true);
+        expect((0, build_file_service_schema_1.isBuildFileKubernetesServiceSchema)({ image: 'node' })).toBe(false);
+    });
+    it('isBuildFileContainerTaskSchema returns true iff the task has an image', () => {
+        expect((0, build_file_task_schema_1.isBuildFileContainerTaskSchema)({ image: 'node' })).toBe(true);
+        expect((0, build_file_task_schema_1.isBuildFileContainerTaskSchema)({ cmds: ['x'] })).toBe(false);
+    });
+    it('isBuildFileLocalTaskSchema returns true iff the task has no image', () => {
+        expect((0, build_file_task_schema_1.isBuildFileLocalTaskSchema)({ cmds: ['x'] })).toBe(true);
+        expect((0, build_file_task_schema_1.isBuildFileLocalTaskSchema)({ image: 'node' })).toBe(false);
+    });
+});
+//# sourceMappingURL=type-guards.spec.js.map

package/dist/schema/work-scope-parser.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkContext = exports.defaultEnvironment = void 0;
+const work_scope_1 = require("../executer/work-scope");
+const label_values_1 = require("../executer/label-values");
+const append_work_service_1 = require("../planner/utils/append-work-service");
+const append_work_task_1 = require("../planner/utils/append-work-task");
+const append_work_environment_1 = require("../planner/utils/append-work-environment");
+function defaultEnvironment(context) {
+    if ('default' in context.environments) {
+        const defaultEnv = context.environments['default'];
+        return (0, append_work_environment_1.appendWorkEnvironment)(defaultEnv);
+    }
+    return {
+        type: 'docker',
+    };
+}
+exports.defaultEnvironment = defaultEnvironment;
+function getWorkContext(context, scope, environment) {
+    const workTree = { services: {}, environment: defaultEnvironment(context), tasks: {} };
+    const filteredWorkTree = { services: {}, environment: defaultEnvironment(context), tasks: {} };
+    for (const [envName, env] of Object.entries(context.environments)) {
+        if (envName === scope.environmentName) {
+            filteredWorkTree.environment = (0, append_work_environment_1.appendWorkEnvironment)(env);
+            workTree.environment = filteredWorkTree.environment;
+        }
+    }
+    for (const task of Object.values(context.tasks)) {
+        const item = (0, append_work_task_1.appendWorkTask)(workTree, task.cwd, task, environment, context);
+        if (matchesTaskWorkScope(item, scope)) {
+            applyTask(filteredWorkTree, item);
+        }
+    }
+    for (const service of Object.values(context.services)) {
+        const item = (0, append_work_service_1.appendWorkService)(workTree, service, environment, context);
+        if (matchesServiceWorkScope(item.data, scope)) {
+            applyService(filteredWorkTree, item);
+        }
+    }
+    return filteredWorkTree;
+}
+exports.getWorkContext = getWorkContext;
+function applyTask(workTree, item) {
+    if (workTree.tasks[item.name]) {
+        return;
+    }
+    workTree.tasks[item.name] = item;
+    applyNeedsAndDeps(workTree, item);
+}
+function applyService(workTree, item) {
+    if (workTree.services[item.name]) {
+        return;
+    }
+    workTree.services[item.name] = item;
+    applyNeedsAndDeps(workTree, item);
+}
+function applyNeedsAndDeps(workTree, item) {
+    for (const dep of item.deps) {
+        applyTask(workTree, dep);
+    }
+    for (const need of item.needs) {
+        applyService(workTree, need.service);
+    }
+}
+function matchesTaskWorkScope(task, scope) {
+    if ((0, work_scope_1.isContextTaskFilter)(scope)) {
+        return task.name === scope.taskName;
+    }
+    return (0, label_values_1.appliesToLabels)(task.data.labels, scope);
+}
+function matchesServiceWorkScope(service, scope) {
+    if ((0, work_scope_1.isContextTaskFilter)(scope)) {
+        return false;
+    }
+    return (0, label_values_1.appliesToLabels)(service.labels, scope);
+}
+//# sourceMappingURL=work-scope-parser.js.map

package/dist/schema/work-scope-parser.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const work_scope_parser_1 = require("./work-scope-parser");
+const test_case_1 = require("../testing/test-case");
+const program_1 = require("../program");
+const path_1 = require("path");
+async function withCli(buildFile, scope, fn) {
+    const testCase = (0, test_case_1.createTestCase)('work-scope-parser', { '.hammerkit.yaml': buildFile });
+    await testCase.setup(async (cwd, environment) => {
+        const cli = await (0, program_1.createCli)((0, path_1.join)(cwd, '.hammerkit.yaml'), environment, scope);
+        await fn(cli);
+    });
+}
+describe('work-scope-parser', () => {
+    describe('defaultEnvironment', () => {
+        it('falls back to docker when no default environment is declared', () => {
+            expect((0, work_scope_parser_1.defaultEnvironment)({ environments: {} })).toEqual({ type: 'docker' });
+        });
+        it('uses a declared docker default environment', () => {
+            const context = {
+                environments: { default: { schema: { docker: { host: 'tcp://remote:2375' } } } },
+            };
+            expect((0, work_scope_parser_1.defaultEnvironment)(context)).toEqual({ type: 'docker', host: 'tcp://remote:2375' });
+        });
+        it('uses a declared kubernetes default environment', () => {
+            const context = {
+                environments: { default: { schema: { kubernetes: { context: 'prod' } } } },
+            };
+            expect((0, work_scope_parser_1.defaultEnvironment)(context)).toEqual({
+                type: 'kubernetes',
+                context: 'prod',
+                ingresses: [],
+                namespace: 'default',
+            });
+        });
+    });
+    describe('getWorkContext (via createCli)', () => {
+        it('includes only the requested task and its dependencies', async () => {
+            await withCli({
+                tasks: {
+                    install: { cmds: ['npm install'] },
+                    build: { cmds: ['tsc'], deps: ['install'] },
+                    lint: { cmds: ['eslint'] },
+                },
+            }, { taskName: 'build' }, (cli) => {
+                const names = cli
+                    .tasks()
+                    .map((t) => t.item.name)
+                    .sort();
+                expect(names).toEqual(['build', 'install']);
+                expect(() => cli.task('lint')).toThrow('unable to find task lint');
+            });
+        });
+        it('filters tasks by label', async () => {
+            await withCli({
+                tasks: {
+                    build: { cmds: ['tsc'], labels: { app: 'web' } },
+                    lint: { cmds: ['eslint'], labels: { app: 'tool' } },
+                },
+            }, { filterLabels: { app: ['web'] } }, (cli) => {
+                expect(cli.tasks().map((t) => t.item.name)).toEqual(['build']);
+            });
+        });
+    });
+});
+//# sourceMappingURL=work-scope-parser.spec.js.map

package/dist/service/update-service-status.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateServiceStatus = void 0;
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+async function updateServiceStatus(workTree) {
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        await service.runtime.initialize(service.state);
+    }
+}
+exports.updateServiceStatus = updateServiceStatus;
+//# sourceMappingURL=update-service-status.js.map

package/dist/service/update-service-status.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const update_service_status_1 = require("./update-service-status");
+function fakeService(initialize) {
+    return {
+        state: { current: { type: 'pending' } },
+        runtime: { initialize },
+    };
+}
+describe('updateServiceStatus', () => {
+    it('calls initialize(state) on every service runtime', async () => {
+        const a = vi.fn().mockResolvedValue(undefined);
+        const b = vi.fn().mockResolvedValue(undefined);
+        const workTree = {
+            services: { svcA: fakeService(a), svcB: fakeService(b) },
+            tasks: {},
+        };
+        await (0, update_service_status_1.updateServiceStatus)(workTree);
+        expect(a).toHaveBeenCalledTimes(1);
+        expect(b).toHaveBeenCalledTimes(1);
+    });
+    it('is a no-op when the work tree has no services', async () => {
+        const workTree = { services: {}, tasks: {} };
+        await expect((0, update_service_status_1.updateServiceStatus)(workTree)).resolves.toBeUndefined();
+    });
+});
+//# sourceMappingURL=update-service-status.spec.js.map