agentic-workflow-manager 9.17.0 → 9.19.0

package/dist/tests/commands/registry/scaffold.test.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const types_1 = require("../../../src/core/facts/types");
+const versioning_1 = require("../../../src/core/versioning");
+const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t ${cmd}`, { cwd, stdio: 'pipe' });
+describe('scaffoldRegistry (RF-4.1, RF-4.2, RF-4.3)', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-scaffold-'));
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    function loadScaffold() {
+        return require('../../../src/commands/registry/scaffold');
+    }
+    function loadDoctor() {
+        return require('../../../src/commands/registry/doctor');
+    }
+    function loadValidate() {
+        return require('../../../src/core/registries');
+    }
+    it('writes min layout with versions, facts, handbook; doctor structural empty (RF-4.1/4.2)', () => {
+        const dir = path_1.default.join(tmp, 'new-reg');
+        const { scaffoldRegistry } = loadScaffold();
+        const result = scaffoldRegistry(dir);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'awm-registry.json'), 'utf-8'));
+        expect(typeof manifest.minCliVersion).toBe('string');
+        expect(manifest.minCliVersion).not.toMatch(/^v/i);
+        expect((0, versioning_1.compareSemver)(manifest.minCliVersion, types_1.FACTS_MIN_CLI_VERSION)).toBeGreaterThanOrEqual(0);
+        const catalog = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'catalog.json'), 'utf-8'));
+        expect(catalog).toEqual({ version: 1, bundles: [] });
+        expect(fs_1.default.statSync(path_1.default.join(dir, 'skills')).isDirectory()).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'skills', '.gitkeep'))).toBe(true);
+        const facts = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'facts.json'), 'utf-8'));
+        expect(facts).toEqual({ schemaVersion: 1, facts: {} });
+        const handbook = fs_1.default.readFileSync(path_1.default.join(dir, 'REGISTRY.md'), 'utf-8');
+        expect(handbook).toMatch(/^##\s+Capabilities\s*$/m);
+        expect(handbook).toMatch(/^\|\s*id\s*\|\s*status\s*\|\s*notes\s*\|$/m);
+        const capsStart = handbook.search(/^##\s+Capabilities\s*$/m);
+        const nextH2 = handbook.slice(capsStart + 1).search(/^##\s+/m);
+        const capsWindow = nextH2 === -1
+            ? handbook.slice(capsStart)
+            : handbook.slice(capsStart, capsStart + 1 + nextH2);
+        expect(capsWindow).toMatch(/\|\s*facts\s*\|\s*active\s*\|/);
+        expect(handbook).toMatch(/^##\s+Capability:\s*facts\s*$/m);
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry(dir).structural).toEqual([]);
+    });
+    it('survives git commit+clone: layout valid and doctor structural empty (RF-4.1)', () => {
+        const src = path_1.default.join(tmp, 'scaffold-src');
+        const { scaffoldRegistry } = loadScaffold();
+        const scaffolded = scaffoldRegistry(src);
+        expect(scaffolded.ok).toBe(true);
+        if (!scaffolded.ok)
+            return;
+        GIT(src, 'init -q');
+        GIT(src, 'add -A');
+        GIT(src, 'commit -qm scaffold');
+        const clone = path_1.default.join(tmp, 'scaffold-clone');
+        (0, child_process_1.execSync)(`git clone -q "${src}" "${clone}"`, { stdio: 'pipe' });
+        expect(fs_1.default.existsSync(path_1.default.join(clone, 'skills', '.gitkeep'))).toBe(true);
+        const { validateRegistryLayout } = loadValidate();
+        expect(validateRegistryLayout(clone)).toBe(true);
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry(clone).structural).toEqual([]);
+    });
+    it('addRegistry accepts local path clone of scaffolded registry (RF-4.1)', async () => {
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-scaffold-add-home-'));
+        const prevHome = process.env.HOME;
+        const prevAwm = process.env.AWM_HOME;
+        process.env.HOME = home;
+        process.env.AWM_HOME = path_1.default.join(home, '.awm');
+        jest.resetModules();
+        try {
+            const src = path_1.default.join(tmp, 'scaffold-for-add');
+            const { scaffoldRegistry } = require('../../../src/commands/registry/scaffold');
+            const scaffolded = scaffoldRegistry(src);
+            expect(scaffolded.ok).toBe(true);
+            if (!scaffolded.ok)
+                return;
+            GIT(src, 'init -q');
+            GIT(src, 'add -A');
+            GIT(src, 'commit -qm scaffold');
+            const { addRegistry } = require('../../../src/commands/registry/add');
+            const { validateRegistryLayout, registryContentRoot } = require('../../../src/core/registries');
+            const result = await addRegistry(src, 'scaffold-local');
+            expect(result.ok).toBe(true);
+            if (!result.ok)
+                return;
+            expect(validateRegistryLayout(registryContentRoot('scaffold-local'))).toBe(true);
+            const { doctorRegistry } = require('../../../src/commands/registry/doctor');
+            expect(doctorRegistry(registryContentRoot('scaffold-local')).structural).toEqual([]);
+        }
+        finally {
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+            if (prevHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = prevHome;
+            if (prevAwm === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = prevAwm;
+        }
+    });
+    it('refuses non-empty existing dir without writing (RF-4.3)', () => {
+        const dir = path_1.default.join(tmp, 'occupied');
+        fs_1.default.mkdirSync(dir);
+        const sentinel = path_1.default.join(dir, 'keep-me.txt');
+        fs_1.default.writeFileSync(sentinel, 'pre-existing\n');
+        const { scaffoldRegistry } = loadScaffold();
+        const result = scaffoldRegistry(dir);
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            return;
+        expect(result.error).toMatch(/exist|non-empty|not empty|overwrite/i);
+        expect(fs_1.default.readFileSync(sentinel, 'utf-8')).toBe('pre-existing\n');
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'awm-registry.json'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'REGISTRY.md'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'facts.json'))).toBe(false);
+    });
+    it('cleans up a directory it created when a mid-write fails (RF-4.3)', () => {
+        const dir = path_1.default.join(tmp, 'partial-fail');
+        expect(fs_1.default.existsSync(dir)).toBe(false);
+        const { scaffoldRegistry } = loadScaffold();
+        let writes = 0;
+        const result = scaffoldRegistry(dir, {
+            writeFileSync: (file, data) => {
+                writes += 1;
+                if (writes >= 3) {
+                    throw new Error('injected write failure');
+                }
+                fs_1.default.writeFileSync(file, data);
+            },
+        });
+        expect(result.ok).toBe(false);
+        if (result.ok)
+            return;
+        expect(result.error).toContain('injected write failure');
+        expect(fs_1.default.existsSync(dir)).toBe(false);
+    });
+    it('empty preexisting target: mid-fail leaves it empty so retry succeeds (RF-4.3)', () => {
+        const dir = path_1.default.join(tmp, 'empty-preexisting');
+        fs_1.default.mkdirSync(dir);
+        expect(fs_1.default.readdirSync(dir)).toEqual([]);
+        const { scaffoldRegistry } = loadScaffold();
+        let writes = 0;
+        const failed = scaffoldRegistry(dir, {
+            writeFileSync: (file, data) => {
+                writes += 1;
+                if (writes >= 3) {
+                    throw new Error('injected write failure');
+                }
+                fs_1.default.writeFileSync(file, data);
+            },
+        });
+        expect(failed.ok).toBe(false);
+        if (failed.ok)
+            return;
+        expect(failed.error).toContain('injected write failure');
+        // Target must not hold partial scaffold files (stage-then-rename).
+        if (fs_1.default.existsSync(dir)) {
+            expect(fs_1.default.readdirSync(dir)).toEqual([]);
+        }
+        const retry = scaffoldRegistry(dir);
+        expect(retry.ok).toBe(true);
+        if (!retry.ok)
+            return;
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'awm-registry.json'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'REGISTRY.md'))).toBe(true);
+        const { doctorRegistry } = loadDoctor();
+        expect(doctorRegistry(dir).structural).toEqual([]);
+    });
+});