opencastle 0.10.7 → 0.12.0

package/dist/cli/run/schema.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseYaml, parseTimeout, validateSpec, applyDefaults } from './schema.js';
+import { parseYaml, parseTimeout, validateSpec, applyDefaults, isConvoySpec } from './schema.js';
 // ── parseYaml ──────────────────────────────────────────────────
 describe('parseYaml', () => {
     it('parses valid YAML mapping', () => {
@@ -299,4 +299,601 @@ describe('applyDefaults', () => {
         expect(task.files).toEqual(['src/']);
     });
 });
+// ── loop mode — validateSpec ───────────────────────────────────
+describe('validateSpec — loop mode', () => {
+    const validLoopSpec = {
+        name: 'build-auth',
+        mode: 'loop',
+        adapter: 'copilot',
+        loop: {
+            prompt: 'PROMPT_build.md',
+            plan_file: 'IMPLEMENTATION_PLAN.md',
+            max_iterations: 20,
+            timeout: '10m',
+            model: 'gpt-5.1',
+            backpressure: ['npm test', 'npx tsc --noEmit'],
+        },
+    };
+    it('accepts a valid minimal loop spec (only prompt required)', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT_build.md' },
+        });
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('accepts a full loop spec', () => {
+        const result = validateSpec(validLoopSpec);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('does not require tasks array in loop mode', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT_build.md' },
+        });
+        expect(result.valid).toBe(true);
+    });
+    it('fails when loop object is missing', () => {
+        const result = validateSpec({ name: 'build-auth', mode: 'loop' });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('`loop` is required'));
+    });
+    it('fails when loop.prompt is missing', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { max_iterations: 10 },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.prompt'));
+    });
+    it('fails when loop.prompt is not a string', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 123 },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.prompt'));
+    });
+    it('fails when loop.max_iterations is 0', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', max_iterations: 0 },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.max_iterations'));
+    });
+    it('fails when loop.max_iterations is a float', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', max_iterations: 1.5 },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.max_iterations'));
+    });
+    it('fails when loop.timeout has invalid format', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', timeout: 'bad' },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.timeout'));
+    });
+    it('accepts valid loop.timeout formats', () => {
+        for (const t of ['5s', '10m', '2h']) {
+            const result = validateSpec({
+                name: 'build-auth',
+                mode: 'loop',
+                loop: { prompt: 'PROMPT.md', timeout: t },
+            });
+            expect(result.valid).toBe(true);
+        }
+    });
+    it('fails when loop.backpressure is not an array', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', backpressure: 'npm test' },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.backpressure'));
+    });
+    it('fails when loop.backpressure contains non-strings', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', backpressure: ['npm test', 42] },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.backpressure'));
+    });
+    it('fails when loop.plan_file is not a string', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', plan_file: true },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.plan_file'));
+    });
+    it('fails when loop.model is not a string', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md', model: 99 },
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('loop.model'));
+    });
+    it('rejects unknown mode value', () => {
+        const result = validateSpec({
+            name: 'build-auth',
+            mode: 'parallel',
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('mode'));
+    });
+    it('mode: tasks still requires tasks array', () => {
+        const result = validateSpec({ name: 'build-auth', mode: 'tasks' });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('tasks'));
+    });
+    it('spec without mode field defaults to tasks behavior (requires tasks)', () => {
+        const result = validateSpec({ name: 'build-auth' });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('tasks'));
+    });
+});
+// ── loop mode — applyDefaults ──────────────────────────────────
+describe('applyDefaults — loop mode', () => {
+    it('applies default max_iterations', () => {
+        const spec = applyDefaults({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md' },
+        });
+        expect(spec.loop?.max_iterations).toBe(20);
+    });
+    it('applies default plan_file', () => {
+        const spec = applyDefaults({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md' },
+        });
+        expect(spec.loop?.plan_file).toBe('IMPLEMENTATION_PLAN.md');
+    });
+    it('applies default timeout', () => {
+        const spec = applyDefaults({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md' },
+        });
+        expect(spec.loop?.timeout).toBe('10m');
+    });
+    it('preserves user-specified loop values', () => {
+        const spec = applyDefaults({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: {
+                prompt: 'PROMPT.md',
+                max_iterations: 5,
+                plan_file: 'MY_PLAN.md',
+                timeout: '30m',
+                model: 'gpt-5.1',
+                backpressure: ['npm test'],
+            },
+        });
+        expect(spec.loop?.max_iterations).toBe(5);
+        expect(spec.loop?.plan_file).toBe('MY_PLAN.md');
+        expect(spec.loop?.timeout).toBe('30m');
+        expect(spec.loop?.model).toBe('gpt-5.1');
+        expect(spec.loop?.backpressure).toEqual(['npm test']);
+    });
+    it('sets mode to tasks when not specified', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.mode).toBe('tasks');
+    });
+    it('preserves mode: loop', () => {
+        const spec = applyDefaults({
+            name: 'build-auth',
+            mode: 'loop',
+            loop: { prompt: 'PROMPT.md' },
+        });
+        expect(spec.mode).toBe('loop');
+    });
+});
+// ── validateSpec — version field ───────────────────────────────
+describe('validateSpec — version field', () => {
+    const validSpec = {
+        name: 'test-run',
+        tasks: [{ id: 'task-1', prompt: 'Do something' }],
+    };
+    it('accepts version 1', () => {
+        const result = validateSpec({ ...validSpec, version: 1 });
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('rejects version 2', () => {
+        const result = validateSpec({ ...validSpec, version: 2 });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('version'));
+    });
+    it('rejects non-integer version', () => {
+        const result = validateSpec({ ...validSpec, version: 1.5 });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('version'));
+    });
+    it('rejects string version', () => {
+        const result = validateSpec({ ...validSpec, version: '1' });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('version'));
+    });
+    it('omitting version is valid (legacy spec)', () => {
+        const result = validateSpec(validSpec);
+        expect(result.valid).toBe(true);
+    });
+});
+// ── validateSpec — defaults block ──────────────────────────────
+describe('validateSpec — defaults block', () => {
+    const validSpec = {
+        name: 'test-run',
+        version: 1,
+        tasks: [{ id: 'task-1', prompt: 'Do something' }],
+    };
+    it('accepts a fully specified defaults block', () => {
+        const result = validateSpec({
+            ...validSpec,
+            defaults: { timeout: '10m', model: 'gpt-4', max_retries: 2, agent: 'developer' },
+        });
+        expect(result.valid).toBe(true);
+    });
+    it('accepts partial defaults block', () => {
+        const result = validateSpec({ ...validSpec, defaults: { timeout: '5m' } });
+        expect(result.valid).toBe(true);
+    });
+    it('rejects defaults as a non-object', () => {
+        const result = validateSpec({ ...validSpec, defaults: 'invalid' });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults'));
+    });
+    it('rejects defaults as an array', () => {
+        const result = validateSpec({ ...validSpec, defaults: ['timeout', '10m'] });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults'));
+    });
+    it('rejects defaults with invalid timeout format', () => {
+        const result = validateSpec({ ...validSpec, defaults: { timeout: 'bad' } });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults.timeout'));
+    });
+    it('rejects defaults with non-string model', () => {
+        const result = validateSpec({ ...validSpec, defaults: { model: 42 } });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults.model'));
+    });
+    it('rejects defaults with negative max_retries', () => {
+        const result = validateSpec({ ...validSpec, defaults: { max_retries: -1 } });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults.max_retries'));
+    });
+    it('rejects defaults with non-integer max_retries', () => {
+        const result = validateSpec({ ...validSpec, defaults: { max_retries: 1.5 } });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults.max_retries'));
+    });
+    it('accepts defaults.max_retries of 0', () => {
+        const result = validateSpec({ ...validSpec, defaults: { max_retries: 0 } });
+        expect(result.valid).toBe(true);
+    });
+    it('rejects defaults with non-string agent', () => {
+        const result = validateSpec({ ...validSpec, defaults: { agent: 99 } });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('defaults.agent'));
+    });
+});
+// ── validateSpec — gates field ─────────────────────────────────
+describe('validateSpec — gates field', () => {
+    const validSpec = {
+        name: 'test-run',
+        tasks: [{ id: 'task-1', prompt: 'Do something' }],
+    };
+    it('accepts a valid gates array', () => {
+        const result = validateSpec({
+            ...validSpec,
+            gates: ['npm test', 'npx tsc --noEmit'],
+        });
+        expect(result.valid).toBe(true);
+    });
+    it('accepts an empty gates array', () => {
+        const result = validateSpec({ ...validSpec, gates: [] });
+        expect(result.valid).toBe(true);
+    });
+    it('rejects gates as a string', () => {
+        const result = validateSpec({ ...validSpec, gates: 'npm test' });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('gates'));
+    });
+    it('rejects gates with non-string items', () => {
+        const result = validateSpec({ ...validSpec, gates: ['npm test', 42] });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('gates'));
+    });
+});
+// ── validateSpec — branch field ────────────────────────────────
+describe('validateSpec — branch field', () => {
+    const validSpec = {
+        name: 'test-run',
+        tasks: [{ id: 'task-1', prompt: 'Do something' }],
+    };
+    it('accepts a valid branch string', () => {
+        const result = validateSpec({ ...validSpec, branch: 'feat/my-feature' });
+        expect(result.valid).toBe(true);
+    });
+    it('rejects non-string branch', () => {
+        const result = validateSpec({ ...validSpec, branch: 123 });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('branch'));
+    });
+    it('rejects boolean branch', () => {
+        const result = validateSpec({ ...validSpec, branch: true });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('branch'));
+    });
+});
+// ── validateSpec — per-task model and max_retries ──────────────
+describe('validateSpec — per-task model and max_retries', () => {
+    it('accepts valid task model string', () => {
+        const result = validateSpec({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', model: 'claude-3.5-sonnet' }],
+        });
+        expect(result.valid).toBe(true);
+    });
+    it('rejects non-string task model', () => {
+        const result = validateSpec({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', model: 123 }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('model'));
+    });
+    it('accepts valid task max_retries', () => {
+        const result = validateSpec({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', max_retries: 3 }],
+        });
+        expect(result.valid).toBe(true);
+    });
+    it('accepts zero max_retries', () => {
+        const result = validateSpec({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', max_retries: 0 }],
+        });
+        expect(result.valid).toBe(true);
+    });
+    it('rejects negative max_retries', () => {
+        const result = validateSpec({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', max_retries: -1 }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('max_retries'));
+    });
+    it('rejects non-integer max_retries', () => {
+        const result = validateSpec({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', max_retries: 1.5 }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContainEqual(expect.stringContaining('max_retries'));
+    });
+});
+// ── isConvoySpec ───────────────────────────────────────────────
+describe('isConvoySpec', () => {
+    it('returns true for version 1 spec', () => {
+        expect(isConvoySpec({ name: 'test', version: 1, tasks: [{ id: 'a', prompt: 'x' }] })).toBe(true);
+    });
+    it('returns false for legacy spec without version', () => {
+        expect(isConvoySpec({ name: 'test', tasks: [{ id: 'a', prompt: 'x' }] })).toBe(false);
+    });
+    it('returns false for version 2', () => {
+        expect(isConvoySpec({ name: 'test', version: 2 })).toBe(false);
+    });
+    it('returns false for null input', () => {
+        expect(isConvoySpec(null)).toBe(false);
+    });
+    it('returns false for non-object input', () => {
+        expect(isConvoySpec('string')).toBe(false);
+    });
+    it('returns false for undefined', () => {
+        expect(isConvoySpec(undefined)).toBe(false);
+    });
+});
+// ── applyDefaults — convoy spec (version: 1) ───────────────────
+describe('applyDefaults — convoy spec (version: 1)', () => {
+    it('merges defaults.agent into tasks when not specified', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { agent: 'ui-ux-expert' },
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].agent).toBe('ui-ux-expert');
+    });
+    it('task-level agent overrides default', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { agent: 'ui-ux-expert' },
+            tasks: [{ id: 'a', prompt: 'x', agent: 'api-designer' }],
+        });
+        expect(spec.tasks[0].agent).toBe('api-designer');
+    });
+    it('merges defaults.timeout into tasks', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { timeout: '15m' },
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].timeout).toBe('15m');
+    });
+    it('task-level timeout overrides defaults.timeout', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { timeout: '15m' },
+            tasks: [{ id: 'a', prompt: 'x', timeout: '5m' }],
+        });
+        expect(spec.tasks[0].timeout).toBe('5m');
+    });
+    it('merges defaults.model into tasks', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { model: 'gpt-4' },
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].model).toBe('gpt-4');
+    });
+    it('task-level model overrides defaults.model', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { model: 'gpt-4' },
+            tasks: [{ id: 'a', prompt: 'x', model: 'claude-3.5-sonnet' }],
+        });
+        expect(spec.tasks[0].model).toBe('claude-3.5-sonnet');
+    });
+    it('no model set when no defaults.model and no task model', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].model).toBeUndefined();
+    });
+    it('merges defaults.max_retries into tasks', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { max_retries: 3 },
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].max_retries).toBe(3);
+    });
+    it('task-level max_retries overrides defaults.max_retries', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { max_retries: 3 },
+            tasks: [{ id: 'a', prompt: 'x', max_retries: 0 }],
+        });
+        expect(spec.tasks[0].max_retries).toBe(0);
+    });
+    it('propagates version and defaults fields through to spec', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            defaults: { model: 'gpt-4' },
+            gates: ['npm test'],
+            branch: 'feat/convoy',
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.version).toBe(1);
+        expect(spec.gates).toEqual(['npm test']);
+        expect(spec.branch).toBe('feat/convoy');
+    });
+});
+// ── applyDefaults — max_retries default always applied ─────────
+describe('applyDefaults — max_retries always applied', () => {
+    it('applies max_retries default of 1 for legacy spec', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].max_retries).toBe(1);
+    });
+    it('applies max_retries default of 1 when version:1 has no defaults block', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            version: 1,
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        expect(spec.tasks[0].max_retries).toBe(1);
+    });
+    it('preserves explicit task max_retries in legacy spec', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x', max_retries: 5 }],
+        });
+        expect(spec.tasks[0].max_retries).toBe(5);
+    });
+});
+// ── backward compatibility ─────────────────────────────────────
+describe('backward compatibility — legacy specs', () => {
+    it('legacy spec validates identically without version field', () => {
+        const result = validateSpec({
+            name: 'test-run',
+            tasks: [
+                { id: 'task-1', prompt: 'Do something' },
+                { id: 'task-2', prompt: 'Do another thing', depends_on: ['task-1'] },
+            ],
+        });
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('legacy spec applyDefaults produces same agent/timeout/depends_on/files as before', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        const task = spec.tasks[0];
+        expect(task.agent).toBe('developer');
+        expect(task.timeout).toBe('30m');
+        expect(task.depends_on).toEqual([]);
+        expect(task.files).toEqual([]);
+    });
+    it('user-specified legacy task values are preserved', () => {
+        const spec = applyDefaults({
+            name: 'test',
+            tasks: [{
+                    id: 'a',
+                    prompt: 'x',
+                    agent: 'ui-ux-expert',
+                    timeout: '5m',
+                    depends_on: ['b'],
+                    files: ['src/'],
+                }],
+        });
+        const task = spec.tasks[0];
+        expect(task.agent).toBe('ui-ux-expert');
+        expect(task.timeout).toBe('5m');
+        expect(task.depends_on).toEqual(['b']);
+        expect(task.files).toEqual(['src/']);
+    });
+    it('defaults block is ignored without version:1', () => {
+        // Without version:1, the defaults block should not be merged
+        const spec = applyDefaults({
+            name: 'test',
+            defaults: { agent: 'ui-ux-expert', model: 'gpt-4' },
+            tasks: [{ id: 'a', prompt: 'x' }],
+        });
+        // agent falls back to hardcoded 'developer', not defaults.agent
+        expect(spec.tasks[0].agent).toBe('developer');
+        // model is not set
+        expect(spec.tasks[0].model).toBeUndefined();
+    });
+});
 //# sourceMappingURL=schema.test.js.map