elsabro 5.2.0 → 6.0.1

package/flow-engine/tests/executors-complex.test.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  executeAgent,
+  executeParallel,
+  executeInterrupt,
+  executeTeam,
+  NotImplementedError
+} = require('../src/executors');
+
+function makeContext(overrides = {}) {
+  return {
+    inputs: { task: 'test task', profile: 'default', complexity: 'medium', ...overrides.inputs },
+    nodes: { ...overrides.nodes },
+    steps: { ...overrides.steps },
+    state: { ...overrides.state },
+    _iterations: {}
+  };
+}
+
+describe('executeAgent', () => {
+  it('invokes callback with resolved inputs and stores output', async () => {
+    let capturedConfig = null;
+    const callbacks = {
+      onAgent: async (config) => {
+        capturedConfig = config;
+        return { files: ['auth.js'], summary: 'Added auth' };
+      }
+    };
+
+    const ctx = makeContext({ inputs: { task: 'add auth' } });
+    const result = await executeAgent(
+      {
+        id: 'merge_analysis',
+        type: 'agent',
+        agent: 'elsabro-analyst',
+        config: { model: 'opus' },
+        inputs: { task: '{{inputs.task}}', extra: 'data' },
+        next: 'next_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'next_node');
+    assert.equal(capturedConfig.id, 'merge_analysis');
+    assert.equal(capturedConfig.agent, 'elsabro-analyst');
+    assert.equal(capturedConfig.inputs.task, 'add auth');
+    assert.equal(capturedConfig.inputs.extra, 'data');
+    assert.ok(ctx.nodes.merge_analysis.outputs);
+  });
+
+  it('handles missing callback gracefully', async () => {
+    const ctx = makeContext();
+    const result = await executeAgent(
+      {
+        id: 'agent1',
+        type: 'agent',
+        agent: 'test',
+        next: 'done'
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, 'done');
+  });
+});
+
+describe('executeParallel', () => {
+  it('resolves branch inputs and invokes onParallel', async () => {
+    let capturedParallel = null;
+    const callbacks = {
+      onParallel: async (config) => {
+        capturedParallel = config;
+        return config.branches.map(b => ({ id: b.id, result: `done-${b.id}` }));
+      },
+      onTeamRequired: async () => {}
+    };
+
+    const ctx = makeContext({ inputs: { task: 'test' } });
+    const result = await executeParallel(
+      {
+        id: 'standard_analyze',
+        type: 'parallel',
+        branches: [
+          { id: 'explore', agent: 'Explore', inputs: { task: '{{inputs.task}}' } },
+          { id: 'plan', agent: 'Plan', inputs: { task: '{{inputs.task}}' } },
+          { id: 'debt', agent: 'general-purpose', inputs: {} }
+        ],
+        joinType: 'all',
+        next: 'merge'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'merge');
+    assert.equal(capturedParallel.joinType, 'all');
+    assert.equal(capturedParallel.branches.length, 3);
+    assert.equal(capturedParallel.branches[0].inputs.task, 'test');
+    assert.ok(result.outputs.branches.explore);
+    assert.ok(result.outputs.branches.plan);
+    assert.ok(result.outputs.branches.debt);
+  });
+
+  it('calls onTeamRequired when branches >= 2', async () => {
+    let teamCalled = false;
+    const callbacks = {
+      onTeamRequired: async () => { teamCalled = true; },
+      onParallel: async ({ branches }) => branches.map(() => ({ result: 'ok' }))
+    };
+
+    const ctx = makeContext();
+    await executeParallel(
+      {
+        id: 'par',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }],
+        next: 'done'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(teamCalled, true);
+  });
+
+  it('triggers onMaxIterations after reaching limit', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => branches.map(() => ({ result: 'ok' }))
+    };
+
+    const ctx = makeContext();
+
+    // First 2 iterations should go to 'next'
+    const result1 = await executeParallel(
+      {
+        id: 'fix_issues',
+        type: 'parallel',
+        branches: [{ id: 'a' }],
+        next: 'quality_gate',
+        maxIterations: 3,
+        onMaxIterations: 'interrupt_manual_fix'
+      },
+      ctx,
+      callbacks
+    );
+    assert.equal(result1.next, 'quality_gate');
+
+    const result2 = await executeParallel(
+      {
+        id: 'fix_issues',
+        type: 'parallel',
+        branches: [{ id: 'a' }],
+        next: 'quality_gate',
+        maxIterations: 3,
+        onMaxIterations: 'interrupt_manual_fix'
+      },
+      ctx,
+      callbacks
+    );
+    assert.equal(result2.next, 'quality_gate');
+
+    // Third iteration should hit maxIterations
+    const result3 = await executeParallel(
+      {
+        id: 'fix_issues',
+        type: 'parallel',
+        branches: [{ id: 'a' }],
+        next: 'quality_gate',
+        maxIterations: 3,
+        onMaxIterations: 'interrupt_manual_fix'
+      },
+      ctx,
+      callbacks
+    );
+    assert.equal(result3.next, 'interrupt_manual_fix');
+  });
+});
+
+describe('executeInterrupt', () => {
+  it('routes based on user selection', async () => {
+    const callbacks = {
+      onInterrupt: async (display) => {
+        assert.equal(display.nodeId, 'int1');
+        assert.ok(display.display.title);
+        return 'approve';
+      }
+    };
+
+    const result = await executeInterrupt(
+      {
+        id: 'int1',
+        type: 'interrupt',
+        reason: 'Plan needs approval',
+        display: {
+          title: 'Review Plan',
+          options: [
+            { id: 'approve', label: 'Approve' },
+            { id: 'reject', label: 'Reject' }
+          ]
+        },
+        routes: { approve: 'implement', reject: 'cancel' }
+      },
+      makeContext(),
+      callbacks
+    );
+
+    assert.equal(result.next, 'implement');
+    assert.equal(result.outputs.selection, 'approve');
+  });
+
+  it('throws when selected option has no route', async () => {
+    const callbacks = {
+      onInterrupt: async () => 'unknown_option'
+    };
+
+    await assert.rejects(
+      executeInterrupt(
+        {
+          id: 'int',
+          type: 'interrupt',
+          display: { options: [] },
+          routes: { approve: 'a' }
+        },
+        makeContext(),
+        callbacks
+      ),
+      /no matching route/
+    );
+  });
+
+  it('picks first option when no callback provided', async () => {
+    const result = await executeInterrupt(
+      {
+        id: 'int',
+        type: 'interrupt',
+        display: {
+          title: 'Choose',
+          options: [{ id: 'approve', label: 'Approve' }]
+        },
+        routes: { approve: 'next' }
+      },
+      makeContext(),
+      {}
+    );
+
+    assert.equal(result.next, 'next');
+    assert.equal(result.outputs.selection, 'approve');
+  });
+});
+
+describe('executeTeam', () => {
+  it('throws NotImplementedError for deprecated team nodes', async () => {
+    await assert.rejects(
+      executeTeam(
+        {
+          id: 'teams_spawn',
+          type: 'team',
+          runtime_status: 'not_implemented',
+          gaps: ['Deprecated — Agent Teams now handled inline']
+        },
+        makeContext(),
+        {}
+      ),
+      (err) => {
+        assert.equal(err.name, 'NotImplementedError');
+        assert.equal(err.nodeId, 'teams_spawn');
+        assert.ok(err.message.includes('Deprecated'));
+        return true;
+      }
+    );
+  });
+
+  it('delegates to callback if team is not deprecated', async () => {
+    let teamCalled = false;
+    const callbacks = {
+      onTeam: async (node) => {
+        teamCalled = true;
+        return { teamResult: 'ok' };
+      }
+    };
+
+    const result = await executeTeam(
+      {
+        id: 'custom_team',
+        type: 'team',
+        runtime_status: 'implemented',
+        next: 'done'
+      },
+      makeContext(),
+      callbacks
+    );
+
+    assert.equal(teamCalled, true);
+    assert.equal(result.next, 'done');
+  });
+});

package/flow-engine/tests/executors.test.js

@@ -0,0 +1,326 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  executeEntry,
+  executeExit,
+  executeCondition,
+  executeRouter,
+  executeSequence,
+  getExecutor,
+  checkRuntimeStatus,
+  NotImplementedError,
+  ExecutorError
+} = require('../src/executors');
+
+// Shared empty context
+function makeContext(overrides = {}) {
+  return {
+    inputs: { task: 'test task', profile: 'default', complexity: 'medium', ...overrides.inputs },
+    nodes: { ...overrides.nodes },
+    steps: { ...overrides.steps },
+    state: { ...overrides.state },
+    _iterations: {}
+  };
+}
+
+describe('checkRuntimeStatus', () => {
+  it('does nothing for implemented nodes', () => {
+    assert.doesNotThrow(() =>
+      checkRuntimeStatus({ id: 'a', runtime_status: 'implemented' })
+    );
+  });
+
+  it('does nothing for partial nodes', () => {
+    assert.doesNotThrow(() =>
+      checkRuntimeStatus({ id: 'a', runtime_status: 'partial' })
+    );
+  });
+
+  it('throws NotImplementedError for not_implemented', () => {
+    assert.throws(
+      () => checkRuntimeStatus({
+        id: 'interview_yolo',
+        runtime_status: 'not_implemented',
+        gaps: ['No interview command exists']
+      }),
+      (err) => {
+        assert.equal(err.name, 'NotImplementedError');
+        assert.ok(err.message.includes('interview_yolo'));
+        assert.ok(err.message.includes('No interview command exists'));
+        assert.equal(err.nodeId, 'interview_yolo');
+        return true;
+      }
+    );
+  });
+});
+
+describe('executeEntry', () => {
+  it('returns next node with empty outputs', async () => {
+    const result = await executeEntry(
+      { id: 'start', type: 'entry', next: 'skill_discovery' },
+      makeContext(),
+      {}
+    );
+    assert.equal(result.next, 'skill_discovery');
+    assert.deepEqual(result.outputs, {});
+  });
+});
+
+describe('executeExit', () => {
+  it('resolves output templates and returns null next', async () => {
+    const ctx = makeContext({ inputs: { task: 'my task' } });
+    const result = await executeExit(
+      {
+        id: 'end',
+        type: 'exit',
+        status: 'success',
+        outputs: { success: true, task: '{{inputs.task}}' }
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, null);
+    assert.equal(result.outputs.success, true);
+    assert.equal(result.outputs.task, 'my task');
+    assert.equal(result.status, 'success');
+  });
+
+  it('handles exit with no outputs', async () => {
+    const result = await executeExit(
+      { id: 'end', type: 'exit', status: 'cancelled' },
+      makeContext(),
+      {}
+    );
+    assert.equal(result.next, null);
+    assert.deepEqual(result.outputs, {});
+  });
+});
+
+describe('executeCondition', () => {
+  it('routes to true branch when condition is true', async () => {
+    const ctx = makeContext({
+      nodes: {
+        quality_gate: { outputs: { tests: { exitCode: 0 } } }
+      }
+    });
+    const result = await executeCondition(
+      {
+        id: 'check',
+        type: 'condition',
+        condition: '{{nodes.quality_gate.outputs.tests.exitCode === 0}}',
+        true: 'review',
+        false: 'fix'
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, 'review');
+    assert.equal(result.outputs.conditionResult, true);
+  });
+
+  it('routes to false branch when condition is false', async () => {
+    const ctx = makeContext({
+      nodes: {
+        quality_gate: { outputs: { tests: { exitCode: 1 } } }
+      }
+    });
+    const result = await executeCondition(
+      {
+        id: 'check',
+        type: 'condition',
+        condition: '{{nodes.quality_gate.outputs.tests.exitCode === 0}}',
+        true: 'review',
+        false: 'fix'
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, 'fix');
+    assert.equal(result.outputs.conditionResult, false);
+  });
+
+  it('throws on missing condition', async () => {
+    await assert.rejects(
+      executeCondition({ id: 'c', type: 'condition', true: 'a', false: 'b' }, makeContext(), {}),
+      ExecutorError
+    );
+  });
+});
+
+describe('executeRouter', () => {
+  it('routes based on input value', async () => {
+    const ctx = makeContext({ inputs: { profile: 'yolo' } });
+    const result = await executeRouter(
+      {
+        id: 'router',
+        type: 'router',
+        condition: '{{inputs.profile}}',
+        routes: {
+          yolo: 'interview_yolo',
+          careful: 'interview_careful',
+          default: 'interview_default'
+        },
+        default: 'interview_default'
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, 'interview_yolo');
+    assert.equal(result.outputs.routeKey, 'yolo');
+  });
+
+  it('falls back to default route when no match', async () => {
+    const ctx = makeContext({ inputs: { profile: 'unknown_profile' } });
+    const result = await executeRouter(
+      {
+        id: 'router',
+        type: 'router',
+        condition: '{{inputs.profile}}',
+        routes: {
+          yolo: 'interview_yolo',
+          careful: 'interview_careful'
+        },
+        default: 'interview_default'
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, 'interview_default');
+  });
+
+  it('throws when no route matches and no default', async () => {
+    const ctx = makeContext({ inputs: { profile: 'unknown' } });
+    await assert.rejects(
+      executeRouter(
+        {
+          id: 'router',
+          type: 'router',
+          condition: '{{inputs.profile}}',
+          routes: { yolo: 'a' }
+        },
+        ctx,
+        {}
+      ),
+      /could not match/
+    );
+  });
+});
+
+describe('executeSequence', () => {
+  it('executes steps and resolves outputs', async () => {
+    const callbacks = {
+      onBash: async (cmd) => ({ output: '{"skills": ["context7"]}', exitCode: 0 })
+    };
+    const ctx = makeContext();
+    const result = await executeSequence(
+      {
+        id: 'seq',
+        type: 'sequence',
+        steps: [
+          { action: 'bash', command: 'echo test', as: 'step1' }
+        ],
+        outputs: { result: '{{steps.step1.output.output}}' },
+        next: 'next_node'
+      },
+      ctx,
+      callbacks
+    );
+    assert.equal(result.next, 'next_node');
+    assert.equal(result.outputs.result, '{"skills": ["context7"]}');
+    assert.ok(ctx.steps.step1); // Step was stored
+  });
+
+  it('continues on optional step failure', async () => {
+    const ctx = makeContext();
+    const callbacks = {
+      onReadFiles: async () => { throw new Error('file not found'); }
+    };
+    const result = await executeSequence(
+      {
+        id: 'seq',
+        type: 'sequence',
+        steps: [
+          { action: 'read_files', files: ['missing.md'], optional: true, as: 'files' }
+        ],
+        next: 'done'
+      },
+      ctx,
+      callbacks
+    );
+    assert.equal(result.next, 'done');
+    assert.ok(ctx.steps.files.error); // Error was recorded
+  });
+
+  it('continues on errorPolicy=continue', async () => {
+    const ctx = makeContext();
+    const callbacks = {
+      onBash: async () => { throw new Error('command failed'); }
+    };
+    const result = await executeSequence(
+      {
+        id: 'seq',
+        type: 'sequence',
+        errorPolicy: 'continue',
+        steps: [
+          { action: 'bash', command: 'bad', as: 'bad_step' }
+        ],
+        next: 'done'
+      },
+      ctx,
+      callbacks
+    );
+    assert.equal(result.next, 'done');
+  });
+
+  it('throws on step failure without optional or errorPolicy', async () => {
+    const callbacks = {
+      onBash: async () => { throw new Error('boom'); }
+    };
+    await assert.rejects(
+      executeSequence(
+        {
+          id: 'seq',
+          type: 'sequence',
+          steps: [{ action: 'bash', command: 'fail', as: 'x' }],
+          next: 'done'
+        },
+        makeContext(),
+        callbacks
+      ),
+      ExecutorError
+    );
+  });
+
+  it('skips unrecognized step actions gracefully', async () => {
+    const ctx = makeContext();
+    const result = await executeSequence(
+      {
+        id: 'seq',
+        type: 'sequence',
+        steps: [
+          { action: 'learn_patterns', as: 'learn' }
+        ],
+        next: 'done'
+      },
+      ctx,
+      {}
+    );
+    assert.equal(result.next, 'done');
+    assert.ok(ctx.steps.learn.output.skipped);
+  });
+});
+
+describe('getExecutor', () => {
+  it('returns executors for all 9 types', () => {
+    const types = ['entry', 'exit', 'condition', 'router', 'sequence', 'agent', 'parallel', 'interrupt', 'team'];
+    for (const type of types) {
+      assert.equal(typeof getExecutor(type), 'function', `Missing executor for "${type}"`);
+    }
+  });
+
+  it('throws for unknown type', () => {
+    assert.throws(() => getExecutor('subflow'), /No executor/);
+  });
+});