agentic-workflow-manager 9.19.0 → 9.20.0

package/dist/tests/core/changes/helpers.js

@@ -0,0 +1,269 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonRepoDir = exports.bad = exports.posixOnly = void 0;
+exports.emptyGitConfig = emptyGitConfig;
+exports.makeRepo = makeRepo;
+exports.gitVersion = gitVersion;
+exports.gitAtLeast = gitAtLeast;
+exports.cloneRepo = cloneRepo;
+exports.expectLinearScaling = expectLinearScaling;
+exports.spyOnGit = spyOnGit;
+exports.withEnv = withEnv;
+exports.importCommits = importCommits;
+exports.branchOff = branchOff;
+exports.commitForgedSigned = commitForgedSigned;
+exports.showSignaturesInLog = showSignaturesInLog;
+exports.makeHiddenSubmodule = makeHiddenSubmodule;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = __importStar(require("child_process"));
+// Git's identity and config isolation travel in an explicit environment object for the helper's own git calls.
+// HOME, AWM_HOME and the git config variables are also overridden on `process.env` (and restored), so that code under
+// test (which hands process.env to git) can never reach the real `~/.awm` or the developer's / system git config.
+const ENV_KEYS = ['HOME', 'AWM_HOME', 'GIT_CONFIG_GLOBAL', 'GIT_CONFIG_NOSYSTEM'];
+/**
+ * An empty, real global git config inside `home`. `os.devNull` is not usable for GIT_CONFIG_GLOBAL: on Windows it is `\\.\nul`, which
+ * git cannot open (`fatal: unable to access '\\.\nul': Invalid argument`). A real empty file isolates the developer's config everywhere.
+ */
+function emptyGitConfig(home) {
+    const file = path_1.default.join(home, 'gitconfig');
+    fs_1.default.writeFileSync(file, '');
+    return file;
+}
+/** The git runner of a repository: identity and config isolation in an explicit environment, optional explicit dates. */
+function gitApi(root, home) {
+    const env = {
+        ...process.env, HOME: home, GIT_CONFIG_GLOBAL: path_1.default.join(home, 'gitconfig'), GIT_CONFIG_NOSYSTEM: '1',
+        GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t',
+    };
+    const run = (extra, args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env: { ...env, ...extra } }).trim();
+    const dates = (date) => {
+        const stamp = `${Math.floor(Date.parse(date) / 1000)} +0000`;
+        return { GIT_AUTHOR_DATE: stamp, GIT_COMMITTER_DATE: stamp };
+    };
+    const git = (...args) => run({}, args);
+    const gitInput = (input, ...args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env, input }).trim();
+    const gitAt = (date, ...args) => run(dates(date), args);
+    const commit = (files, message, date) => {
+        for (const [rel, content] of Object.entries(files)) {
+            const abs = path_1.default.join(root, rel);
+            fs_1.default.mkdirSync(path_1.default.dirname(abs), { recursive: true });
+            fs_1.default.writeFileSync(abs, content);
+        }
+        git('add', '-A');
+        run(date === undefined ? {} : dates(date), ['commit', '-q', '-m', message]);
+        return git('rev-parse', 'HEAD');
+    };
+    return { git, gitInput, gitAt, commit };
+}
+/** Isolated repo: HOME/AWM_HOME point at a tmpdir; never touches the real ~/.awm. */
+function makeRepo() {
+    const saved = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    const home = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-')));
+    Object.assign(process.env, { HOME: home, AWM_HOME: path_1.default.join(home, '.awm'), GIT_CONFIG_GLOBAL: emptyGitConfig(home), GIT_CONFIG_NOSYSTEM: '1' });
+    const root = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-chg-')));
+    const { git, gitInput, gitAt, commit } = gitApi(root, home);
+    const cleanup = () => {
+        for (const [k, v] of Object.entries(saved)) {
+            if (v === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = v;
+        }
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    };
+    try {
+        git('init', '-q', '-b', 'main');
+        commit({ '.gitignore': '.awm/\n', 'README.md': 'x' }, 'chore: init');
+    }
+    catch (error) {
+        cleanup();
+        throw error;
+    }
+    return { root, home, git, gitInput, gitAt, commit, cleanup };
+}
+/** The version of the installed git as [major, minor], or null when it cannot be read. */
+function gitVersion() {
+    try {
+        const m = /^git version (\d+)\.(\d+)/.exec((0, child_process_1.execFileSync)('git', ['--version'], { encoding: 'utf8' }));
+        return m ? [Number(m[1]), Number(m[2])] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when the installed git is `major.minor` or newer (false when its version cannot be read). */
+function gitAtLeast(major, minor) {
+    const v = gitVersion();
+    return v !== null && (v[0] > major || (v[0] === major && v[1] >= minor));
+}
+/** `test` where symlinks and POSIX modes exist; reported as skipped (not as passed) on Windows. */
+exports.posixOnly = process.platform === 'win32' ? test.skip : test;
+/**
+ * A copy of `template` in its own directory (same throwaway home, same git isolation): a few milliseconds instead of the
+ * several git processes `makeRepo` spawns. For suites that need a fresh repository per test. `cleanup` removes only the copy;
+ * the template's `cleanup` removes the shared home and restores the environment.
+ */
+function cloneRepo(template) {
+    const root = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-chg-')));
+    fs_1.default.cpSync(template.root, root, { recursive: true });
+    const { git, gitInput, gitAt, commit } = gitApi(root, template.home);
+    return { root, home: template.home, git, gitInput, gitAt, commit, cleanup: () => fs_1.default.rmSync(root, { recursive: true, force: true }) };
+}
+/**
+ * For the linear-time tests of PURE code (no git child): `run(n)` is called with a small and a 10x larger input and the best of a
+ * few runs of each is compared. Linear code takes about 10x as long; a quadratic scan about 100x. The bound is 40x the small time
+ * (floored at 1 ms so a clock tick is not a ratio), which separates the two with a margin on both sides and does not depend on
+ * how fast or how loaded the runner is. `base` must be large enough for a quadratic scan to cost milliseconds at that size.
+ */
+function expectLinearScaling(run, base) {
+    const best = (n) => {
+        let min = Infinity;
+        for (let i = 0; i < 3; i++) {
+            const started = performance.now();
+            run(n);
+            min = Math.min(min, performance.now() - started);
+        }
+        return min;
+    };
+    run(Math.max(1, Math.floor(base / 10))); // warm-up: JIT and caches
+    const small = Math.max(best(base), 1);
+    const large = best(base * 10);
+    expect({ small, large, bounded: large <= 40 * small }).toMatchObject({ bounded: true });
+}
+/** Casts a deliberately wrong value to whatever the function under test declares. */
+const bad = (v) => v;
+exports.bad = bad;
+/**
+ * Spies on every git child the code under test spawns (`child_process.execFileSync`): records each argv in `calls` and then runs
+ * the real git, unless `intercept` throws (to simulate a failing or timed-out git). Undo with `restore()` (or `jest.restoreAllMocks`).
+ */
+function spyOnGit(intercept) {
+    const calls = [];
+    const real = child_process_1.default.execFileSync;
+    const spy = jest.spyOn(child_process_1.default, 'execFileSync').mockImplementation(((cmd, args, opts) => {
+        if (cmd === 'git')
+            calls.push(args);
+        intercept?.(args);
+        return real(cmd, args, opts);
+    }));
+    return { calls, restore: () => spy.mockRestore() };
+}
+/** Sets variables on process.env (the environment runGit hands to git) for the duration of `fn`. */
+function withEnv(vars, fn) {
+    const saved = Object.fromEntries(Object.keys(vars).map((k) => [k, process.env[k]]));
+    Object.assign(process.env, vars);
+    try {
+        return fn();
+    }
+    finally {
+        for (const [k, v] of Object.entries(saved)) {
+            if (v === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = v;
+        }
+    }
+}
+/**
+ * Adds many commits on top of the current branch with ONE `git fast-import` process (instead of one add + commit per commit), then
+ * resets the working tree to the new tip. Explicit identity and committer dates; the history is what `repo.commit` would build.
+ */
+function importCommits(repo, commits) {
+    const ref = `refs/heads/${repo.git('symbolic-ref', '--short', 'HEAD')}`;
+    const parts = [];
+    commits.forEach((c, i) => {
+        const when = `${Math.floor(Date.parse(c.date) / 1000)} +0000`;
+        const bytes = (text) => `data ${Buffer.byteLength(text)}\n${text}\n`;
+        parts.push(`commit ${ref}\nauthor t <t@t> ${when}\ncommitter t <t@t> ${when}\n${bytes(c.message)}`);
+        if (i === 0)
+            parts.push(`from ${ref}^0\n`);
+        for (const [rel, content] of Object.entries(c.files))
+            parts.push(`M 100644 inline ${rel}\n${bytes(content)}`);
+        parts.push('\n');
+    });
+    repo.gitInput(parts.join(''), 'fast-import', '--quiet');
+    repo.git('reset', '-q', '--hard');
+}
+/** Checks out `feat/x` and returns the commit it forked from (main). */
+function branchOff(repo) {
+    repo.git('checkout', '-q', '-b', 'feat/x');
+    return repo.git('rev-parse', 'main');
+}
+/** A directory that is not a git repository. */
+const nonRepoDir = (repo) => fs_1.default.mkdtempSync(path_1.default.join(repo.home, 'plain-'));
+exports.nonRepoDir = nonRepoDir;
+/** A commit carrying a forged `gpgsig` header, written straight into the object store (no gpg needed). */
+function commitForgedSigned(repo, message, file = 'signed.ts') {
+    fs_1.default.writeFileSync(path_1.default.join(repo.root, file), '1');
+    repo.git('add', '-A');
+    const body = [`tree ${repo.git('write-tree')}`, `parent ${repo.git('rev-parse', 'HEAD')}`, 'author t <t@t> 1700000000 +0000', 'committer t <t@t> 1700000000 +0000',
+        'gpgsig -----BEGIN PGP SIGNATURE-----', ' ', ' forged', ' -----END PGP SIGNATURE-----', '', message, ''].join('\n');
+    const bodyFile = path_1.default.join(repo.home, 'forged-commit.txt');
+    fs_1.default.writeFileSync(bodyFile, body);
+    const sha = repo.git('hash-object', '-t', 'commit', '-w', bodyFile);
+    repo.git('reset', '-q', '--hard', sha);
+    return sha;
+}
+/** Repo-local config (the helper only isolates the global one): git prints verification text before each signed commit. */
+function showSignaturesInLog(repo) {
+    repo.git('config', 'log.showSignature', 'true');
+    repo.git('config', 'gpg.program', process.execPath); // any program that writes to stderr; the output is what matters, not a real gpg
+}
+/**
+ * Offline fixture: a nested repository at `relPath` registered as a gitlink of the repository at `root`, hidden by
+ * `.gitmodules` `ignore = all` and the repo-local `diff.ignoreSubmodules=all`, then committed. Returns helpers to run git
+ * inside it and to commit there (which moves the checkout away from the recorded gitlink).
+ */
+function makeHiddenSubmodule(root, run, relPath = 'vendor/sm') {
+    const dir = path_1.default.join(root, ...relPath.split('/'));
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    const inSm = (...args) => run(dir, ...args);
+    const commitInSm = (name) => { fs_1.default.writeFileSync(path_1.default.join(dir, name), name); inSm('add', '-A'); inSm('commit', '-q', '-m', `feat: ${name}`); return inSm('rev-parse', 'HEAD'); };
+    inSm('init', '-q', '-b', 'main');
+    const first = commitInSm('one');
+    fs_1.default.writeFileSync(path_1.default.join(root, '.gitmodules'), `[submodule "${relPath}"]\n\tpath = ${relPath}\n\turl = ./nowhere\n\tignore = all\n`);
+    run(root, 'config', 'diff.ignoreSubmodules', 'all');
+    run(root, 'add', '.gitmodules');
+    run(root, 'update-index', '--add', '--cacheinfo', `160000,${first},${relPath}`);
+    run(root, 'commit', '-q', '-m', 'chore: add submodule');
+    return { dir, inSm, commitInSm };
+}

package/dist/tests/core/changes/list-fixtures.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.byClass = exports.subjects = exports.listIn = exports.FIRST = exports.UNSAFE = exports.recordPath = exports.SINCE_48H = exports.now = exports.NOW = exports.SHA = void 0;
+exports.record = record;
+exports.commitLiterally = commitLiterally;
+exports.ok = ok;
+exports.adoptIn = adoptIn;
+exports.historyIn = historyIn;
+exports.snapshotDir = snapshotDir;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const list_1 = require("../../../src/core/changes/list");
+// Shared by the tests of `awm changes list`: a valid record text and the clock every list test runs at.
+exports.SHA = 'a'.repeat(40);
+/** The instant every list test pretends to run at. */
+exports.NOW = new Date('2026-10-17T12:00:00.000Z');
+const now = () => exports.NOW;
+exports.now = now;
+/** The start of the `48h` window at NOW. */
+exports.SINCE_48H = new Date('2026-10-15T12:00:00.000Z');
+/** A valid Change Record whose id is `id` (it must equal the file name without `.md`). */
+function record(id, o = {}) {
+    const manual = o.manual ?? [['s1', 'e1'], ['s2', 'e2']];
+    const manualYaml = Array.isArray(manual)
+        ? manual.map(([step, expected]) => `  - step: ${step}\n    expected: ${expected}`).join('\n')
+        : `  none: ${manual.none}`;
+    return `---
+schema: awm.change-record/v1
+id: ${id}
+title: "${o.title ?? `T ${id}`}"
+summary_short: "${o.summary ?? 'Primer cambio.'}"
+type: ${o.type ?? 'feat'}
+scope: null
+semver: minor
+breaking: false
+modules: [cli]
+verification:
+  commit: ${exports.SHA}
+  overall: ${o.overall ?? 'pass'}
+  sensors: { lint: pass }
+  receipt_digest: sha256:${'b'.repeat(64)}
+manual_validation:
+${manualYaml}
+risks: []
+rollback: revert
+${o.extra ?? ''}---
+## Qué se hizo
+a
+## Qué se probó
+b
+## Qué falta validar
+c
+## Riesgos y rollback
+d
+`;
+}
+const recordPath = (id) => `docs/changes/${id}.md`;
+exports.recordPath = recordPath;
+let oddCommits = 0;
+/**
+ * A commit on top of HEAD whose committer line is `committer t <t@t> <committerDate>` verbatim (git itself would never write an
+ * empty, negative or garbage date), written straight into the object store and checked out. Returns its id.
+ */
+function commitLiterally(repo, committerDate, message = 'fix: odd date') {
+    const body = [`tree ${repo.git('write-tree')}`, `parent ${repo.git('rev-parse', 'HEAD')}`, 'author t <t@t> 1700000000 +0000', `committer t <t@t> ${committerDate}`, '', message, ''].join('\n');
+    const file = path_1.default.join(repo.home, `odd-commit-${oddCommits++}.txt`);
+    fs_1.default.writeFileSync(file, body);
+    const sha = repo.git('hash-object', '-t', 'commit', '-w', '--literally', file);
+    repo.git('reset', '-q', '--hard', sha);
+    return sha;
+}
+exports.UNSAFE = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+exports.FIRST = '2026-10-16-first';
+const listIn = (repo, opts = {}) => (0, list_1.listChanges)(repo.root, { since: exports.SINCE_48H, ...opts });
+exports.listIn = listIn;
+function ok(outcome) {
+    if (!outcome.ok)
+        throw new Error(`expected ok, got ${outcome.failure.code}: ${outcome.failure.message}`);
+    return outcome.result;
+}
+const subjects = (r) => r.changes.map((c) => c.subject);
+exports.subjects = subjects;
+const byClass = (r) => Object.fromEntries(r.changes.map((c) => [c.subject, c.classification]));
+exports.byClass = byClass;
+/** The commit that opens the adoption point, before the 48h window. */
+function adoptIn(repo, id = '2026-10-10-adopt') {
+    return repo.commit({ [(0, exports.recordPath)(id)]: record(id, { summary: 'Adopcion.' }) }, 'feat: adopt', '2026-10-10T00:00:00Z');
+}
+/** Pre-adoption, recorded, missing, exempt and invalid-record commits, tagged v1.0.0. */
+function historyIn(repo) {
+    repo.commit({ 'old.ts': '1' }, 'feat: before adoption', '2026-10-16T09:00:00Z');
+    repo.commit({ [(0, exports.recordPath)(exports.FIRST)]: record(exports.FIRST), 'a.ts': '1' }, 'feat: first (#10)', '2026-10-16T20:00:00Z');
+    repo.commit({ 'b.ts': '1' }, 'fix: no record', '2026-10-16T21:00:00Z');
+    repo.commit({ 'c.ts': '1' }, 'chore(release): v1.0.0 [skip ci]\n\nChange-Record: none', '2026-10-16T22:00:00Z');
+    repo.commit({ [(0, exports.recordPath)('2026-10-17-bad')]: '---\nschema: nope\n---\n' }, 'feat: bad record', '2026-10-17T01:00:00Z');
+    repo.gitAt('2026-10-17T02:00:00Z', 'tag', '-a', 'v1.0.0', '-m', 'v1.0.0');
+}
+/**
+ * A digest of every file and directory under `root`, `.git` and its object database included: names and contents, never times.
+ * Two equal digests mean that nothing was written, fetched or refreshed in between.
+ */
+function snapshotDir(root) {
+    const hash = crypto_1.default.createHash('sha1');
+    const walk = (dir, rel) => {
+        for (const name of fs_1.default.readdirSync(dir).sort()) {
+            const abs = path_1.default.join(dir, name);
+            const here = `${rel}/${name}`;
+            if (fs_1.default.lstatSync(abs).isDirectory()) {
+                hash.update(`d ${here}\n`);
+                walk(abs, here);
+            }
+            else
+                hash.update(`f ${here} ${crypto_1.default.createHash('sha1').update(fs_1.default.readFileSync(abs)).digest('hex')}\n`);
+        }
+    };
+    walk(root, '');
+    return hash.digest('hex');
+}

package/dist/tests/core/changes/list-long-history.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+const list_fixtures_1 = require("./list-fixtures");
+const list_1 = require("../../../src/core/changes/list");
+// One 201-commit repository, built once and only ever read: no test writes into it and no test needs a repository of its own.
+let big;
+beforeAll(() => {
+    big = (0, helpers_1.makeRepo)();
+    big.commit({ [(0, list_fixtures_1.recordPath)('2026-10-10-adopt')]: (0, list_fixtures_1.record)('2026-10-10-adopt') }, 'feat: adopt', '2026-10-10T00:00:00Z');
+    // 201 empty commits with the same committer date, written by ONE git fast-import process instead of 201 `git commit`s.
+    (0, helpers_1.importCommits)(big, Array.from({ length: 201 }, (_, i) => ({ message: `fix: n${i + 1}`, files: {}, date: '2026-10-16T10:00:00Z' })));
+}, 180_000);
+afterAll(() => big.cleanup());
+afterEach(() => jest.restoreAllMocks());
+const listBig = (opts = {}) => (0, list_1.listChanges)(big.root, { since: list_fixtures_1.SINCE_48H, ...opts });
+const result = (outcome) => {
+    if (!outcome.ok)
+        throw new Error(outcome.failure.message);
+    return outcome.result;
+};
+/** How many git children a run spawns. */
+const spawns = (opts) => {
+    const spy = (0, helpers_1.spyOnGit)();
+    result(listBig(opts));
+    spy.restore();
+    return spy.calls.length;
+};
+describe('listChanges: a long history (R5.7)', () => {
+    test('beyond 200 entries only the newest 200 are listed and the rest is counted', () => {
+        const r = result(listBig());
+        expect(r.changes).toHaveLength(200);
+        expect(r.changes[0].subject).toBe('fix: n201');
+        expect(r.changes[199].subject).toBe('fix: n2');
+        expect(r).toMatchObject({ truncated: true, omitted: 1 });
+    }, 180_000);
+    test('the entries beyond a small limit are only counted', () => {
+        expect(result(listBig({ limit: 3 }))).toMatchObject({ truncated: true, omitted: 198 });
+    });
+    test('the whole history fits one page, so the scan is one git call', () => {
+        const spy = (0, helpers_1.spyOnGit)();
+        result(listBig({ limit: 3 }));
+        spy.restore();
+        expect(spy.calls.filter((a) => a.includes('--format=%H%x1f%ct%x1f%P'))).toHaveLength(1);
+    });
+    test('git calls per entry are constant: an entry costs the same however many there are', () => {
+        expect((spawns({ limit: 25 }) - spawns({ limit: 5 })) / 20).toBeLessThanOrEqual(4);
+    });
+    test('entries beyond the limit cost no per-entry call', () => {
+        expect(spawns({ limit: 5 })).toBeLessThan(spawns({ limit: 25 }) / 2);
+    });
+});