agentic-workflow-manager 8.2.1 → 8.3.0

package/dist/tests/core/orchestrators.test.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const orchestrators_1 = require("../../src/core/orchestrators");
+const registries_1 = require("../../src/core/registries");
+function registryWith(manifest) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-'));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify(manifest));
+    return root;
+}
+describe('readDeclaredOrchestrators', () => {
+    const created = [];
+    afterEach(() => {
+        for (const r of created.splice(0))
+            fs_1.default.rmSync(r, { recursive: true, force: true });
+    });
+    it('lee una declaracion valida', () => {
+        const root = registryWith({
+            minCliVersion: '8.1.5',
+            orchestrator: { name: 'mi-proceso', appliesWhen: 'cuando arranco una tarea', terminatesTo: 'development-process' },
+        });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(diagnostics).toEqual([]);
+        expect(orchestrators).toHaveLength(1);
+        expect(orchestrators[0]).toEqual({
+            name: 'mi-proceso',
+            appliesWhen: 'cuando arranco una tarea',
+            terminatesTo: 'development-process',
+        });
+    });
+    it('un registry sin bloque orchestrator no declara nada y no es un error', () => {
+        const root = registryWith({ minCliVersion: '8.1.5' });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toEqual([]);
+    });
+    it('un registry sin manifiesto no declara nada y no es un error', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-'));
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toEqual([]);
+    });
+    it('rechaza una declaracion malformada SIN lanzar, reportandola', () => {
+        const root = registryWith({ orchestrator: { name: 'mi-proceso' } }); // falta appliesWhen y terminatesTo
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/appliesWhen/);
+    });
+    it('rechaza un campo string en blanco (solo espacios) sin lanzar, reportandolo', () => {
+        const root = registryWith({ orchestrator: { name: 'x', appliesWhen: '   ', terminatesTo: 'none' } });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/appliesWhen/);
+    });
+    it('orchestrator: null se rechaza SIN lanzar, reportandolo', () => {
+        const root = registryWith({ orchestrator: null });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/must be an object/i);
+    });
+    it('orchestrator: [] (array) se rechaza SIN lanzar — prueba que Array.isArray se chequea, no solo === null', () => {
+        const root = registryWith({ orchestrator: [] });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/must be an object/i);
+    });
+    it('orchestrator: 5 (numero) se rechaza SIN lanzar', () => {
+        const root = registryWith({ orchestrator: 5 });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/must be an object/i);
+    });
+    it('orchestrator: "x" (string) se rechaza SIN lanzar', () => {
+        const root = registryWith({ orchestrator: 'x' });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/must be an object/i);
+    });
+    it('rechaza un campo que excede la longitud maxima permitida', () => {
+        const root = registryWith({
+            orchestrator: { name: 'x'.repeat(501), appliesWhen: 'y', terminatesTo: 'none' },
+        });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/"name"/);
+        expect(diagnostics[0]).toMatch(/500|maximum|exceeds/i);
+    });
+    it('acepta un campo justo en el limite de longitud maxima (500 caracteres)', () => {
+        const root = registryWith({
+            orchestrator: { name: 'x'.repeat(500), appliesWhen: 'y', terminatesTo: 'none' },
+        });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(diagnostics).toEqual([]);
+        expect(orchestrators).toHaveLength(1);
+    });
+    it('un manifiesto con JSON invalido se reporta, no explota', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-'));
+        created.push(root);
+        fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), '{ no es json');
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+    });
+    it('una declaracion invalida no invalida las validas de otros registries', () => {
+        const bad = registryWith({ orchestrator: { name: 'roto' } });
+        const good = registryWith({
+            orchestrator: { name: 'sano', appliesWhen: 'siempre', terminatesTo: 'none' },
+        });
+        created.push(bad, good);
+        const all = [bad, good].map(orchestrators_1.readDeclaredOrchestrators);
+        expect(all[0].orchestrators).toEqual([]);
+        expect(all[1].orchestrators).toHaveLength(1);
+        expect(all[1].diagnostics).toEqual([]);
+    });
+    it('rechaza campos de precedencia: no son vocabulario del framework', () => {
+        const root = registryWith({
+            orchestrator: { name: 'x', appliesWhen: 'y', terminatesTo: 'none', precedence: 1 },
+        });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics[0]).toMatch(/unknown field "precedence"/i);
+    });
+    it('rechaza una declaracion que traiga secretos', () => {
+        const root = registryWith({
+            orchestrator: { name: 'x', appliesWhen: 'y', terminatesTo: 'none', token: 'ghp_abc' },
+        });
+        created.push(root);
+        const { diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(diagnostics[0]).toMatch(/unknown field "token"/i);
+    });
+    it('rechaza un manifiesto simlinkeado sin lanzar, reportandolo', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-'));
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-outside-'));
+        created.push(root, outside);
+        fs_1.default.writeFileSync(path_1.default.join(outside, 'awm-registry.json'), JSON.stringify({
+            orchestrator: { name: 'sano', appliesWhen: 'siempre', terminatesTo: 'none' },
+        }));
+        fs_1.default.symlinkSync(path_1.default.join(outside, 'awm-registry.json'), path_1.default.join(root, 'awm-registry.json'));
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/symbolic link/i);
+    });
+    it('un nombre de campo con salto de linea no forja lineas de log adicionales', () => {
+        const root = registryWith({
+            orchestrator: { name: 'x', appliesWhen: 'y', terminatesTo: 'none', 'evil\nfake-warning: injected line': true },
+        });
+        created.push(root);
+        const { orchestrators, diagnostics } = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+        expect(orchestrators).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0].split('\n')).toHaveLength(1);
+        expect(diagnostics[0]).toContain(JSON.stringify('evil\nfake-warning: injected line'));
+    });
+});
+describe('collectDeclaredOrchestrators', () => {
+    // Isolates AWM_HOME per CLAUDE.md's testing rule ("ningun test puede tocar el ~/.awm
+    // real") — mirrors the pattern in tests/core/context/orchestrator.test.ts.
+    let isolatedAwmHome;
+    let originalAwmHomeEnv;
+    beforeEach(() => {
+        isolatedAwmHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-collect-home-'));
+        originalAwmHomeEnv = process.env.AWM_HOME;
+        process.env.AWM_HOME = isolatedAwmHome;
+    });
+    afterEach(() => {
+        if (originalAwmHomeEnv === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHomeEnv;
+        fs_1.default.rmSync(isolatedAwmHome, { recursive: true, force: true });
+    });
+    function writeManifest(name, manifest) {
+        const root = (0, registries_1.registryContentRoot)(name);
+        fs_1.default.mkdirSync(root, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify(manifest));
+    }
+    it('dedupea por nombre entre dos registries, conservando el primero por orden de registries.json', () => {
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'first', remote: 'unused' },
+            { name: 'second', remote: 'unused' },
+        ]);
+        writeManifest('first', {
+            orchestrator: { name: 'shared', appliesWhen: 'primero', terminatesTo: 'a' },
+        });
+        writeManifest('second', {
+            orchestrator: { name: 'shared', appliesWhen: 'segundo', terminatesTo: 'b' },
+        });
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared).toHaveLength(1);
+        expect(declared[0]).toEqual({ name: 'shared', appliesWhen: 'primero', terminatesTo: 'a' });
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/shared/);
+        expect(diagnostics[0]).toMatch(/duplicate|shadow/i);
+    });
+    it('no dedupea orquestadores con nombres distintos, ambos se conservan', () => {
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'first', remote: 'unused' },
+            { name: 'second', remote: 'unused' },
+        ]);
+        writeManifest('first', {
+            orchestrator: { name: 'uno', appliesWhen: 'x', terminatesTo: 'a' },
+        });
+        writeManifest('second', {
+            orchestrator: { name: 'dos', appliesWhen: 'y', terminatesTo: 'b' },
+        });
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared).toHaveLength(2);
+        expect(declared.map((d) => d.name).sort()).toEqual(['dos', 'uno']);
+        expect(diagnostics).toEqual([]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "8.2.1",
+  "version": "8.3.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"