@renseiai/agentfactory 0.8.8 → 0.8.10

package/dist/src/workflow/workflow-types.test.js

@@ -1,5 +1,8 @@
-import { describe, it, expect } from 'vitest';
-import { PhaseDefinitionSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, validateWorkflowDefinition, } from './workflow-types.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it, expect, vi } from 'vitest';
+import { parse as parseYaml } from 'yaml';
+import { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, validateWorkflowDefinition, } from './workflow-types.js';
 describe('PhaseDefinitionSchema', () => {
     it('validates a minimal phase', () => {
         const result = PhaseDefinitionSchema.parse({
@@ -48,6 +51,112 @@ describe('PhaseDefinitionSchema', () => {
             template: '',
         })).toThrow();
     });
+    it('validates phase with outputs', () => {
+        const result = PhaseDefinitionSchema.parse({
+            name: 'development',
+            template: 'development',
+            outputs: {
+                prUrl: { type: 'url', description: 'Pull request URL', required: true },
+                branch: { type: 'string' },
+            },
+        });
+        expect(result.outputs).toEqual({
+            prUrl: { type: 'url', description: 'Pull request URL', required: true },
+            branch: { type: 'string' },
+        });
+    });
+    it('validates phase with inputs', () => {
+        const result = PhaseDefinitionSchema.parse({
+            name: 'qa',
+            template: 'qa',
+            inputs: {
+                prUrl: { from: 'development.prUrl', description: 'PR to test' },
+            },
+        });
+        expect(result.inputs).toEqual({
+            prUrl: { from: 'development.prUrl', description: 'PR to test' },
+        });
+    });
+    it('validates phase with both outputs and inputs', () => {
+        const result = PhaseDefinitionSchema.parse({
+            name: 'qa',
+            template: 'qa',
+            inputs: {
+                prUrl: { from: 'development.prUrl' },
+            },
+            outputs: {
+                testsPassed: { type: 'boolean', required: true },
+            },
+        });
+        expect(result.inputs).toBeDefined();
+        expect(result.outputs).toBeDefined();
+    });
+    it('accepts phase without outputs and inputs (backwards compatible)', () => {
+        const result = PhaseDefinitionSchema.parse({
+            name: 'development',
+            template: 'development',
+        });
+        expect(result.outputs).toBeUndefined();
+        expect(result.inputs).toBeUndefined();
+    });
+});
+describe('PhaseOutputDeclarationSchema', () => {
+    it('validates all output types', () => {
+        for (const type of ['string', 'json', 'url', 'boolean']) {
+            const result = PhaseOutputDeclarationSchema.parse({ type });
+            expect(result.type).toBe(type);
+        }
+    });
+    it('validates with all optional fields', () => {
+        const result = PhaseOutputDeclarationSchema.parse({
+            type: 'url',
+            description: 'The pull request URL',
+            required: true,
+        });
+        expect(result.type).toBe('url');
+        expect(result.description).toBe('The pull request URL');
+        expect(result.required).toBe(true);
+    });
+    it('validates minimal declaration', () => {
+        const result = PhaseOutputDeclarationSchema.parse({ type: 'string' });
+        expect(result.type).toBe('string');
+        expect(result.description).toBeUndefined();
+        expect(result.required).toBeUndefined();
+    });
+    it('rejects missing type', () => {
+        expect(() => PhaseOutputDeclarationSchema.parse({})).toThrow();
+    });
+    it('rejects invalid type', () => {
+        expect(() => PhaseOutputDeclarationSchema.parse({ type: 'number' })).toThrow();
+    });
+    it('rejects non-boolean required', () => {
+        expect(() => PhaseOutputDeclarationSchema.parse({
+            type: 'string',
+            required: 'yes',
+        })).toThrow();
+    });
+});
+describe('PhaseInputDeclarationSchema', () => {
+    it('validates a minimal input declaration', () => {
+        const result = PhaseInputDeclarationSchema.parse({
+            from: 'development.prUrl',
+        });
+        expect(result.from).toBe('development.prUrl');
+        expect(result.description).toBeUndefined();
+    });
+    it('validates with description', () => {
+        const result = PhaseInputDeclarationSchema.parse({
+            from: 'development.prUrl',
+            description: 'The PR URL from the development phase',
+        });
+        expect(result.description).toBe('The PR URL from the development phase');
+    });
+    it('rejects missing from', () => {
+        expect(() => PhaseInputDeclarationSchema.parse({})).toThrow();
+    });
+    it('rejects empty from', () => {
+        expect(() => PhaseInputDeclarationSchema.parse({ from: '' })).toThrow();
+    });
 });
 describe('TransitionDefinitionSchema', () => {
     it('validates a minimal transition', () => {
@@ -438,3 +547,185 @@ describe('validateWorkflowDefinition', () => {
         expect(() => validateWorkflowDefinition({ invalid: true })).toThrow();
     });
 });
+// ---------------------------------------------------------------------------
+// Cross-validation tests
+// ---------------------------------------------------------------------------
+describe('validateWorkflowDefinition cross-validation', () => {
+    /** Helper to build a minimal valid workflow with overrides */
+    function makeWorkflow(overrides = {}) {
+        return {
+            apiVersion: 'v1.1',
+            kind: 'WorkflowDefinition',
+            metadata: { name: 'test-cross-validation' },
+            phases: [
+                { name: 'dev', template: 'development' },
+                { name: 'qa', template: 'qa' },
+            ],
+            transitions: [
+                { from: 'Backlog', to: 'dev' },
+            ],
+            ...overrides,
+        };
+    }
+    it('validates example YAML against schema', () => {
+        const examplePath = path.join(path.dirname(new URL(import.meta.url).pathname), 'defaults', 'workflow-parallel-example.yaml');
+        const content = fs.readFileSync(examplePath, 'utf-8');
+        const data = parseYaml(content);
+        const result = validateWorkflowDefinition(data, examplePath);
+        expect(result.metadata.name).toBe('parallel-development');
+        expect(result.parallelism).toHaveLength(1);
+        expect(result.parallelism[0].strategy).toBe('fan-in');
+        expect(result.phases.find(p => p.name === 'development')?.outputs).toBeDefined();
+        expect(result.phases.find(p => p.name === 'qa')?.inputs).toBeDefined();
+    });
+    it('rejects parallelism group referencing undefined phase', () => {
+        expect(() => validateWorkflowDefinition(makeWorkflow({
+            parallelism: [{
+                    name: 'bad-group',
+                    phases: ['nonexistent'],
+                    strategy: 'fan-out',
+                }],
+        }))).toThrow('Parallelism group "bad-group" references undefined phase "nonexistent"');
+    });
+    it('includes file path in parallelism group error', () => {
+        expect(() => validateWorkflowDefinition(makeWorkflow({
+            parallelism: [{
+                    name: 'bad-group',
+                    phases: ['nonexistent'],
+                    strategy: 'fan-out',
+                }],
+        }), '/some/path.yaml')).toThrow('in /some/path.yaml');
+    });
+    it('rejects phase input with invalid from format', () => {
+        expect(() => validateWorkflowDefinition(makeWorkflow({
+            phases: [
+                { name: 'dev', template: 'development' },
+                {
+                    name: 'qa',
+                    template: 'qa',
+                    inputs: { prUrl: { from: 'invalid-no-dot' } },
+                },
+            ],
+        }))).toThrow('expected "phaseName.outputKey" format');
+    });
+    it('rejects phase input with too many dot segments', () => {
+        expect(() => validateWorkflowDefinition(makeWorkflow({
+            phases: [
+                { name: 'dev', template: 'development' },
+                {
+                    name: 'qa',
+                    template: 'qa',
+                    inputs: { prUrl: { from: 'a.b.c' } },
+                },
+            ],
+        }))).toThrow('expected "phaseName.outputKey" format');
+    });
+    it('rejects phase input referencing undefined phase', () => {
+        expect(() => validateWorkflowDefinition(makeWorkflow({
+            phases: [
+                { name: 'dev', template: 'development' },
+                {
+                    name: 'qa',
+                    template: 'qa',
+                    inputs: { prUrl: { from: 'nonexistent.prUrl' } },
+                },
+            ],
+        }))).toThrow('references undefined phase "nonexistent"');
+    });
+    it('rejects phase input referencing undefined output key', () => {
+        expect(() => validateWorkflowDefinition(makeWorkflow({
+            phases: [
+                {
+                    name: 'dev',
+                    template: 'development',
+                    outputs: {
+                        branch: { type: 'string' },
+                    },
+                },
+                {
+                    name: 'qa',
+                    template: 'qa',
+                    inputs: { prUrl: { from: 'dev.prUrl' } },
+                },
+            ],
+        }))).toThrow('references undefined output "prUrl" on phase "dev"');
+    });
+    it('allows phase input referencing phase without outputs declared', () => {
+        // When the source phase has no outputs declared at all, we allow the
+        // reference through — the outputs may be dynamic / not statically declared
+        const result = validateWorkflowDefinition(makeWorkflow({
+            phases: [
+                { name: 'dev', template: 'development' },
+                {
+                    name: 'qa',
+                    template: 'qa',
+                    inputs: { prUrl: { from: 'dev.prUrl' } },
+                },
+            ],
+        }));
+        expect(result.phases).toHaveLength(2);
+    });
+    it('warns on high maxConcurrent', () => {
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            validateWorkflowDefinition(makeWorkflow({
+                parallelism: [{
+                        name: 'big-group',
+                        phases: ['dev'],
+                        strategy: 'fan-out',
+                        maxConcurrent: 20,
+                    }],
+            }));
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('maxConcurrent=20 which may be excessive'));
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('does not warn when maxConcurrent is at or below threshold', () => {
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            validateWorkflowDefinition(makeWorkflow({
+                parallelism: [{
+                        name: 'ok-group',
+                        phases: ['dev'],
+                        strategy: 'fan-out',
+                        maxConcurrent: 10,
+                    }],
+            }));
+            expect(warnSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('passes cross-validation for valid workflow with parallelism and inputs/outputs', () => {
+        const result = validateWorkflowDefinition(makeWorkflow({
+            phases: [
+                {
+                    name: 'dev',
+                    template: 'development',
+                    outputs: {
+                        prUrl: { type: 'url', required: true },
+                    },
+                },
+                {
+                    name: 'qa',
+                    template: 'qa',
+                    inputs: {
+                        prUrls: { from: 'dev.prUrl' },
+                    },
+                },
+            ],
+            parallelism: [{
+                    name: 'dev-fan-in',
+                    phases: ['dev'],
+                    strategy: 'fan-in',
+                    maxConcurrent: 5,
+                    waitForAll: true,
+                }],
+        }));
+        expect(result.parallelism).toHaveLength(1);
+        expect(result.phases.find(p => p.name === 'qa')?.inputs).toBeDefined();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renseiai/agentfactory",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "type": "module",
   "description": "Multi-agent fleet management for coding agents — orchestrator, providers, crash recovery",
   "author": "Rensei AI (https://rensei.ai)",
@@ -55,7 +55,7 @@
     "@types/node": "^22.5.4",
     "typescript": "^5.7.3",
     "vitest": "^3.2.3",
-    "@renseiai/create-agentfactory-app": "0.8.8"
+    "@renseiai/create-agentfactory-app": "0.8.10"
   },
   "scripts": {
     "build": "tsc",