agentic-workflow-manager 9.19.0 → 9.20.0

package/dist/tests/core/changes/parse.test.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_1 = require("../../../src/core/changes/parse");
+describe('isValidSlug', () => {
+    test.each(['a', 'a1', 'a-b-1', '1-2', 'a'.repeat(64)])('accepts %s', (slug) => {
+        expect((0, parse_1.isValidSlug)(slug)).toBe(true);
+    });
+    test.each(['', 'A', 'a_b', 'a--b', '-a', 'a-', 'a b', 'a/b', 'á', 'a'.repeat(65)])('rejects %j', (slug) => {
+        expect((0, parse_1.isValidSlug)(slug)).toBe(false);
+    });
+    test.each([undefined, null, 7, {}, ['a']])('rejects the non-string %j', (slug) => {
+        expect((0, parse_1.isValidSlug)(slug)).toBe(false);
+    });
+});
+describe('isValidRecordFileName', () => {
+    test('accepts date + slug + .md', () => {
+        expect((0, parse_1.isValidRecordFileName)('2026-10-17-change-record.md')).toBe(true);
+    });
+    test.each(['2026-10-17-x.txt', '2026-02-30-x.md', 'x.md', '2026-10-17-.md', '2026-10-17-X.md'])('rejects %s', (name) => {
+        expect((0, parse_1.isValidRecordFileName)(name)).toBe(false);
+    });
+});
+describe('splitRecord', () => {
+    test('splits frontmatter from body', () => {
+        expect((0, parse_1.splitRecord)('---\na: 1\n---\nbody\n')).toEqual({ ok: true, frontmatterText: 'a: 1', body: 'body\n' });
+    });
+    test('normalizes CRLF', () => {
+        expect((0, parse_1.splitRecord)('---\r\na: 1\r\n---\r\nbody\r\n')).toEqual({ ok: true, frontmatterText: 'a: 1', body: 'body\n' });
+    });
+    test('an empty frontmatter block yields empty text', () => {
+        expect((0, parse_1.splitRecord)('---\n---\nbody')).toEqual({ ok: true, frontmatterText: '', body: 'body' });
+    });
+    test.each([['empty input', ''], ['no leading delimiter', 'a: 1\n---\nbody'], ['leading blank line', '\n---\na: 1\n---\nbody']])('%s is frontmatter-missing', (_l, raw) => {
+        const r = (0, parse_1.splitRecord)(raw);
+        expect(r.ok).toBe(false);
+        expect(!r.ok && r.diagnostic.code).toBe('frontmatter-missing');
+    });
+    test('an unclosed frontmatter block is frontmatter-missing', () => {
+        const r = (0, parse_1.splitRecord)('---\na: 1\nbody');
+        expect(r.ok).toBe(false);
+        expect(!r.ok && r.diagnostic.code).toBe('frontmatter-missing');
+    });
+    test('only the first closing delimiter ends the frontmatter', () => {
+        const r = (0, parse_1.splitRecord)('---\na: 1\n---\nx\n---\ny\n');
+        expect(r).toEqual({ ok: true, frontmatterText: 'a: 1', body: 'x\n---\ny\n' });
+    });
+});
+describe('loadFrontmatter', () => {
+    test('parses a mapping and keeps timestamps as strings', () => {
+        expect((0, parse_1.loadFrontmatter)('a: 1\nd: 2026-10-17\nt: 2026-10-17T10:00:00Z')).toEqual({ ok: true, value: { a: 1, d: '2026-10-17', t: '2026-10-17T10:00:00Z' } });
+    });
+    test('empty text loads as undefined and comment-only text as null (both are not mappings)', () => {
+        expect((0, parse_1.loadFrontmatter)('')).toEqual({ ok: true, value: undefined });
+        expect((0, parse_1.loadFrontmatter)('# only a comment')).toEqual({ ok: true, value: null });
+    });
+    test('more than one document is yaml-invalid', () => {
+        const r = (0, parse_1.loadFrontmatter)('a: 1\n---\nb: 2');
+        expect(!r.ok && r.diagnostic.code).toBe('yaml-invalid');
+    });
+    test('custom tags are yaml-invalid', () => {
+        const r = (0, parse_1.loadFrontmatter)('a: !!js/function "f"');
+        expect(!r.ok && r.diagnostic.code).toBe('yaml-invalid');
+    });
+    test('duplicate keys are yaml-invalid', () => {
+        const r = (0, parse_1.loadFrontmatter)('a: 1\na: 2');
+        expect(!r.ok && r.diagnostic.code).toBe('yaml-invalid');
+    });
+    test('merge keys are not expanded (CORE_SCHEMA)', () => {
+        expect((0, parse_1.loadFrontmatter)('a: 1\n<<: {b: 2}')).toEqual({ ok: true, value: { a: 1, '<<': { b: 2 } } });
+    });
+    test('the yaml-invalid reason is JSON-escaped and single-line', () => {
+        const r = (0, parse_1.loadFrontmatter)('a: *x"\\y');
+        expect(r.ok).toBe(false);
+        const d = !r.ok ? r.diagnostic : undefined;
+        expect(d?.code).toBe('yaml-invalid');
+        expect(d?.message.startsWith('frontmatter is not valid YAML:')).toBe(true);
+        expect(d?.message).toContain('alias \\"x\\"\\\\y\\"');
+        expect(d?.message).not.toContain('alias "x"\\y"');
+        expect(d?.message).not.toMatch(/[\n\r]/);
+    });
+    test('an alias without an anchor is yaml-invalid', () => {
+        const r = (0, parse_1.loadFrontmatter)('a: *x');
+        expect(!r.ok && r.diagnostic.code).toBe('yaml-invalid');
+    });
+    // Pins the js-yaml listener contract (`state.anchor` on `close`). If a js-yaml upgrade changes it, these fail loudly
+    // instead of silently allowing anchors.
+    describe('anchor detection (js-yaml listener contract)', () => {
+        test.each([
+            ['a scalar anchor', 'a: &x 1'],
+            ['an unused anchor', 'a: &x 1\nb: 2'],
+            ['a collection anchor', 'a: &x [1, 2]'],
+            ['a mapping anchor', 'a: &x\n  b: 1'],
+            ['a key anchor', '&k a: 1'],
+            ['an anchor and its alias', 'a: &x 1\nb: *x'],
+            ['an anchored top-level mapping', '&top\na: 1'],
+            ['an empty anchored node', 'a: &x'],
+        ])('%s is yaml-alias', (_label, text) => {
+            const r = (0, parse_1.loadFrontmatter)(text);
+            expect(!r.ok && r.diagnostic.code).toBe('yaml-alias');
+        });
+        test.each([['double-quoted', 'a: "&x *x"'], ['single-quoted', "a: '&x *x'"], ['block scalar', 'a: |\n  &x *x'], ['inside a word', 'a: x&y']])('%s look-alike text is accepted', (_label, text) => {
+            expect((0, parse_1.loadFrontmatter)(text).ok).toBe(true);
+        });
+    });
+});
+describe('exported helpers never throw on non-string input', () => {
+    const hostile = [['undefined', undefined], ['null', null], ['a number', 42], ['an object', {}], ['a Buffer', Buffer.from('---\na: 1\n---\nb')], ['an array', []]];
+    test.each(hostile)('splitRecord(%s) is input-invalid', (_label, value) => {
+        let r;
+        expect(() => { r = (0, parse_1.splitRecord)(value); }).not.toThrow();
+        expect(r && !r.ok && r.diagnostic.code).toBe('input-invalid');
+    });
+    test.each(hostile)('loadFrontmatter(%s) is input-invalid', (_label, value) => {
+        let r;
+        expect(() => { r = (0, parse_1.loadFrontmatter)(value); }).not.toThrow();
+        expect(r && !r.ok && r.diagnostic.code).toBe('input-invalid');
+    });
+    test.each([['an array', ['2026-10-17-x.md']], ['a number', 20261017], ['null', null], ['undefined', undefined], ['an object', { toString: () => '2026-10-17-x.md' }]])('isValidRecordFileName(%s) is false', (_label, value) => {
+        expect((0, parse_1.isValidRecordFileName)(value)).toBe(false);
+    });
+    test('loadFrontmatter bounds the message of a huge YAML error', () => {
+        const r = (0, parse_1.loadFrontmatter)(`a: *${'x'.repeat(60000)}`);
+        expect(!r.ok && r.diagnostic.code).toBe('yaml-invalid');
+        expect(!r.ok && r.diagnostic.message.length).toBeLessThanOrEqual(300);
+    });
+    test('loadFrontmatter keeps a surrogate pair whole when it clips', () => {
+        for (const pad of ['', 'x']) {
+            const r = (0, parse_1.loadFrontmatter)(`a: *${pad}${'😀'.repeat(300)}`);
+            const message = !r.ok ? r.diagnostic.message : '';
+            expect(message.length).toBeLessThanOrEqual(300);
+            expect(message).not.toMatch(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/);
+        }
+    });
+});
+describe('isRecordPath (the one copy, used by change validate and changes list)', () => {
+    test.each(['docs/changes/2026-10-17-rec.md', 'docs/changes/2026-10-17-a-b-c.md'])('accepts %s', (rel) => expect((0, parse_1.isRecordPath)(rel)).toBe(true));
+    test.each(['docs/changes/sub/2026-10-17-rec.md', 'docs/changes', 'docs/changes/notes.md', 'docs/changes/2026-10-17-Rec.md', 'other/2026-10-17-rec.md', '/docs/changes/2026-10-17-rec.md', '', 'docs/changes/2026-10-17-rec.md/x'])('rejects %j', (rel) => expect((0, parse_1.isRecordPath)(rel)).toBe(false));
+    test('never throws on non-string input', () => {
+        for (const v of [undefined, null, 5, {}])
+            expect((0, parse_1.isRecordPath)(v)).toBe(false);
+    });
+});

package/dist/tests/core/changes/predicates.test.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../../src/core/changes/types");
+const receipt_1 = require("../../../src/core/changes/receipt");
+const validate_shape_1 = require("../../../src/core/changes/validate-shape");
+const git_1 = require("../../../src/core/changes/git");
+const helpers_1 = require("./helpers");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// One set of predicates for what a receipt, a record and git may hold (types.ts); receipt.ts, validate-shape.ts and git.ts use these.
+const SHA1 = '0123456789abcdef0123456789abcdef01234567';
+const SHA256 = '0123456789abcdef'.repeat(4);
+describe('shared receipt and record predicates', () => {
+    test('a commit id is 40 or 64 lowercase hex characters, and nothing else', () => {
+        expect((0, types_1.isCommitId)(SHA1)).toBe(true);
+        expect((0, types_1.isCommitId)(SHA256)).toBe(true);
+        expect(types_1.COMMIT_ID.test(SHA256)).toBe(true);
+        for (const bad of ['', 'a'.repeat(39), 'a'.repeat(41), 'a'.repeat(63), 'a'.repeat(65), 'A'.repeat(40), 'g'.repeat(40), `${SHA1}\n`, undefined, null, 5])
+            expect((0, types_1.isCommitId)(bad)).toBe(false);
+    });
+    test('the verdicts, the sensor statuses and the sensor names', () => {
+        expect(types_1.OVERALLS).toEqual(['pass', 'fail', 'skipped', 'not_certified']);
+        expect(types_1.SENSOR_STATUSES).toEqual(['pass', 'fail', 'inconclusive', 'skipped']);
+        for (const ok of types_1.OVERALLS)
+            expect((0, types_1.isOverall)(ok)).toBe(true);
+        for (const ok of types_1.SENSOR_STATUSES)
+            expect((0, types_1.isSensorStatus)(ok)).toBe(true);
+        for (const bad of ['great', 'PASS', '', undefined, 1]) {
+            expect((0, types_1.isOverall)(bad)).toBe(false);
+            expect((0, types_1.isSensorStatus)(bad)).toBe(false);
+        }
+        expect((0, types_1.isOverall)('inconclusive')).toBe(false);
+        expect((0, types_1.isSensorStatus)('not_certified')).toBe(false);
+        expect((0, types_1.isSensorName)('lint')).toBe(true);
+        expect((0, types_1.isSensorName)('\u{1F600}'.repeat(types_1.MAX_SENSOR_NAME))).toBe(true);
+        for (const bad of ['', 'a\nb', '\u{1F600}'.repeat(types_1.MAX_SENSOR_NAME + 1), 'a
b', 5, undefined])
+            expect((0, types_1.isSensorName)(bad)).toBe(false);
+    });
+    test('a receipt and a record accept the same commit ids (a sha-256 repository works)', () => {
+        const sensors = [{ name: 'lint', status: 'pass', errors: [] }];
+        for (const commit of [SHA1, SHA256]) {
+            const receipt = (0, receipt_1.buildReceipt)({ commit, ranAt: '2026-10-17T10:00:00.000Z', cliVersion: '1', output: { overall: 'pass', sensors } });
+            expect(receipt.commit).toBe(commit);
+        }
+        for (const bad of ['a'.repeat(63), 'a'.repeat(65)]) {
+            expect(() => (0, receipt_1.buildReceipt)({ commit: bad, ranAt: '2026-10-17T10:00:00.000Z', cliVersion: '1', output: { overall: 'pass', sensors } })).toThrow(/invalid receipt: commit/);
+        }
+    });
+    test('a receipt for a 64-hex commit round-trips through the file', () => {
+        const repo = (0, helpers_1.makeRepo)();
+        try {
+            const receipt = (0, receipt_1.buildReceipt)({ commit: SHA256, ranAt: '2026-10-17T10:00:00.000Z', cliVersion: '1', output: { overall: 'pass', sensors: [{ name: 'lint', status: 'pass', errors: [] }] } });
+            (0, receipt_1.writeReceipt)(repo.root, receipt);
+            expect(fs_1.default.existsSync(path_1.default.join(repo.root, '.awm', 'sensors', 'runs', `${SHA256}.json`))).toBe(true);
+            const read = (0, receipt_1.readReceipt)(repo.root, SHA256);
+            expect(read.ok && read.receipt.commit).toBe(SHA256);
+        }
+        finally {
+            repo.cleanup();
+        }
+    });
+    test('validate-shape accepts a 64-hex verification.commit and rejects 63 and 65', () => {
+        const record = (commit) => ['---', 'schema: awm.change-record/v1', 'id: 2026-10-17-x', 'title: t', 'summary_short: s', 'type: feat', 'scope: null', 'semver: minor', 'breaking: false', 'modules: []',
+            'verification:', `  commit: "${commit}"`, '  overall: pass', '  sensors: {}', `  receipt_digest: "sha256:${'a'.repeat(64)}"`, 'manual_validation:', '  none: n/a', 'risks: []', 'rollback: git revert', '---', '', '## Qué se hizo', 'x', '## Qué se probó', 'x', '## Qué falta validar', 'x', '## Riesgos y rollback', 'x', ''].join('\n');
+        const commitDiagnostics = (commit) => (0, validate_shape_1.validateRecordShape)('2026-10-17-x.md', record(commit)).diagnostics.filter((d) => d.field === 'verification.commit');
+        expect(commitDiagnostics(SHA1)).toEqual([]);
+        expect(commitDiagnostics(SHA256)).toEqual([]);
+        expect(commitDiagnostics('a'.repeat(63))).toHaveLength(1);
+        expect(commitDiagnostics('a'.repeat(65))).toHaveLength(1);
+    });
+    test('git.ts answers commit ids that satisfy the shared predicate', () => {
+        const repo = (0, helpers_1.makeRepo)();
+        try {
+            expect((0, types_1.isCommitId)((0, git_1.commitSha)(repo.root, 'HEAD'))).toBe(true);
+        }
+        finally {
+            repo.cleanup();
+        }
+    });
+});

package/dist/tests/core/changes/range.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+const command_1 = require("../../../src/core/changes/command");
+const range_1 = require("../../../src/core/changes/range");
+let repo;
+/** A repository for the groups that need one (the pure recordDirProblem tests need none). */
+function withRepo() {
+    let template;
+    beforeAll(() => { template = (0, helpers_1.makeRepo)(); });
+    afterAll(() => template.cleanup());
+    beforeEach(() => { repo = (0, helpers_1.cloneRepo)(template); });
+    afterEach(() => repo.cleanup());
+}
+describe('resolveRange', () => {
+    withRepo();
+    test('returns the pinned HEAD and the merge base of the default base', () => {
+        const main = (0, helpers_1.branchOff)(repo);
+        const head = repo.commit({ 'a.ts': '1' }, 'feat: a');
+        expect((0, range_1.resolveRange)(repo.root, undefined)).toEqual({ ok: true, head, mergeBase: main });
+    });
+    test('an explicit base is honoured', () => {
+        const main = (0, helpers_1.branchOff)(repo);
+        repo.commit({ 'a.ts': '1' }, 'feat: a');
+        repo.git('branch', 'other', main);
+        expect((0, range_1.resolveRange)(repo.root, 'other')).toMatchObject({ ok: true, mergeBase: main });
+    });
+    test('an unsafe base is invalid-input, and the value is escaped', () => {
+        const r = (0, range_1.resolveRange)(repo.root, '--x\u001b[0m');
+        expect(r).toMatchObject({ ok: false, failure: { code: 'invalid-input' } });
+        expect(JSON.stringify(r)).not.toContain('\u001b');
+    });
+    test('an unknown base is base-unresolved with the remedy', () => {
+        expect((0, range_1.resolveRange)(repo.root, 'nope')).toEqual({ ok: false, failure: { code: 'base-unresolved', message: 'could not resolve a base branch', remedy: 'pass --base <ref>' } });
+    });
+    test('histories without a common ancestor are base-unresolved (no merge base)', () => {
+        repo.git('checkout', '-q', '--orphan', 'island');
+        repo.git('rm', '-rfq', '.');
+        repo.commit({ 'island.ts': '1' }, 'feat: island');
+        expect((0, range_1.resolveRange)(repo.root, 'main')).toMatchObject({ ok: false, failure: { code: 'base-unresolved', remedy: 'pass --base <ref>' } });
+        expect((0, range_1.resolveRange)(repo.root, 'main').failure.message).toContain('no merge base');
+    });
+    test('an unreadable HEAD is git-failed', () => {
+        expect((0, range_1.resolveRange)((0, helpers_1.nonRepoDir)(repo), undefined)).toMatchObject({ ok: false, failure: { code: 'git-failed' } });
+        expect((0, range_1.resolveRange)((0, helpers_1.bad)(undefined), undefined)).toMatchObject({ ok: false, failure: { code: 'git-failed' } });
+    });
+});
+describe('headMovedFailure', () => {
+    withRepo();
+    test('HEAD moving has its own code, and it is an operational failure (exit 2) like the others', () => {
+        expect(range_1.HEAD_MOVED.code).toBe('head-moved');
+        expect((0, command_1.failed)(range_1.HEAD_MOVED)).toMatchObject({ code: 2, stdout: '' });
+        expect((0, command_1.failed)(range_1.HEAD_MOVED).stderr).toMatch(/^head-moved: HEAD moved during derivation\n$/);
+    });
+    test('is null while HEAD is the pinned commit and HEAD_MOVED once it moved', () => {
+        (0, helpers_1.branchOff)(repo);
+        const head = repo.commit({ 'a.ts': '1' }, 'feat: a');
+        expect((0, range_1.headMovedFailure)(repo.root, head)).toBeNull();
+        repo.commit({ 'b.ts': '1' }, 'feat: b');
+        expect((0, range_1.headMovedFailure)(repo.root, head)).toEqual(range_1.HEAD_MOVED);
+    });
+    test('an unreadable HEAD counts as moved', () => {
+        expect((0, range_1.headMovedFailure)((0, helpers_1.nonRepoDir)(repo), 'a'.repeat(40))).toEqual(range_1.HEAD_MOVED);
+    });
+});
+describe('recordDirProblem', () => {
+    const nonOk = (kind) => ({ kind });
+    const dir = (kind) => (kind === 'ok' ? { kind, dir: '/x' } : { kind });
+    test('a usable or absent directory is no problem for reading and writing', () => {
+        for (const purpose of ['read', 'write']) {
+            expect((0, range_1.recordDirProblem)(dir('ok'), purpose)).toBeNull();
+            expect((0, range_1.recordDirProblem)(dir('absent'), purpose)).toBeNull();
+        }
+    });
+    test('a link or a non-directory is unsafe-path, worded for the purpose', () => {
+        expect((0, range_1.recordDirProblem)(dir('unsafe'), 'read')).toEqual({ code: 'unsafe-path', message: 'docs/changes or its parent is a symlink or not a directory; refusing to read' });
+        expect((0, range_1.recordDirProblem)(dir('unsafe'), 'write')).toEqual({ code: 'unsafe-path', message: 'docs/changes or its parent is a symlink or not a directory; refusing to write' });
+        expect((0, range_1.recordDirProblem)(nonOk('unsafe'), 'create')).toMatchObject({ code: 'unsafe-path' });
+    });
+    test('an unreadable directory is io-failed', () => {
+        expect((0, range_1.recordDirProblem)(dir('error'), 'read')).toEqual({ code: 'io-failed', message: 'could not inspect docs/changes' });
+        expect((0, range_1.recordDirProblem)(nonOk('error'), 'create')).toEqual({ code: 'io-failed', message: 'could not create docs/changes' });
+    });
+    test.each([[null], [undefined], ['ok'], [7], [[]], [{}], [{ kind: 'weird' }], [{ kind: 7 }]])('a value that is not a directory state (%p) is invalid-input, never a throw', (value) => {
+        for (const purpose of ['read', 'write', 'create']) {
+            expect((0, range_1.recordDirProblem)((0, helpers_1.bad)(value), purpose)).toEqual({ code: 'invalid-input', message: 'the record directory state is not valid' });
+        }
+    });
+    test('after a create attempt an absent directory is io-failed too', () => {
+        expect((0, range_1.recordDirProblem)(nonOk('absent'), 'create')).toEqual({ code: 'io-failed', message: 'could not create docs/changes' });
+    });
+});