elsabro 6.0.0 → 7.0.0

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

@@ -0,0 +1,274 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { CallbackProtocol, SUPPORT_AGENTS, PADDING_ORDER } = require('../src/callbacks');
+
+// ---------- requiresTeam ----------
+
+describe('CallbackProtocol: requiresTeam', () => {
+  const protocol = new CallbackProtocol();
+
+  it('returns false for 0 branches', () => {
+    assert.equal(protocol.requiresTeam([]), false);
+  });
+
+  it('returns false for 1 branch', () => {
+    assert.equal(protocol.requiresTeam([
+      { id: 'a', agent: 'x', config: { model: 'opus' } }
+    ]), false);
+  });
+
+  it('returns true for 2+ opus branches', () => {
+    assert.equal(protocol.requiresTeam([
+      { id: 'a', agent: 'x', config: { model: 'opus' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ]), true);
+  });
+
+  it('returns true for mixed haiku/opus branches', () => {
+    assert.equal(protocol.requiresTeam([
+      { id: 'a', agent: 'x', config: { model: 'haiku' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ]), true);
+  });
+
+  it('returns false for 2+ all-haiku branches', () => {
+    assert.equal(protocol.requiresTeam([
+      { id: 'a', agent: 'x', config: { model: 'haiku' } },
+      { id: 'b', agent: 'y', config: { model: 'haiku' } },
+      { id: 'c', agent: 'z', config: { model: 'haiku' } }
+    ]), false);
+  });
+
+  it('returns true for branches with no config (defaults to non-haiku)', () => {
+    assert.equal(protocol.requiresTeam([
+      { id: 'a', agent: 'x' },
+      { id: 'b', agent: 'y' }
+    ]), true);
+  });
+});
+
+// ---------- generateTeamName ----------
+
+describe('CallbackProtocol: generateTeamName', () => {
+  const protocol = new CallbackProtocol();
+
+  it('generates from nodeId alone', () => {
+    const name = protocol.generateTeamName('parallel_implementation');
+    assert.equal(name, 'elsabro-parallel-implementation');
+  });
+
+  it('generates from nodeId + task slug', () => {
+    const name = protocol.generateTeamName('parallel_review', 'auth-feature');
+    assert.equal(name, 'elsabro-parallel-review-auth-feature');
+  });
+
+  it('truncates long names to 38 chars', () => {
+    const name = protocol.generateTeamName('very_long_node_name_that_goes_on', 'and-a-very-long-task-slug');
+    assert.ok(name.length <= 38, `Name "${name}" exceeds 38 chars`);
+    assert.ok(name.startsWith('elsabro-'));
+  });
+});
+
+// ---------- composeTeam ----------
+
+describe('CallbackProtocol: composeTeam', () => {
+  const protocol = new CallbackProtocol();
+
+  it('pads 2 branches to 5 members', () => {
+    const branches = [
+      { id: 'impl', agent: 'elsabro-executor', config: { model: 'opus' } },
+      { id: 'test', agent: 'elsabro-qa', config: { model: 'opus' } }
+    ];
+    const members = protocol.composeTeam(branches, 'implementation');
+    assert.equal(members.length, 5);
+    assert.equal(members[0].agent, 'elsabro-executor');
+    assert.equal(members[1].agent, 'elsabro-qa');
+  });
+
+  it('pads 3 branches to 5 members', () => {
+    const branches = [
+      { id: 'a', agent: 'agent-a' },
+      { id: 'b', agent: 'agent-b' },
+      { id: 'c', agent: 'agent-c' }
+    ];
+    const members = protocol.composeTeam(branches, 'default');
+    assert.equal(members.length, 5);
+  });
+
+  it('does not pad when already 5+ branches', () => {
+    const branches = Array.from({ length: 6 }, (_, i) => ({
+      id: `b${i}`, agent: `agent-${i}`, config: { model: 'opus' }
+    }));
+    const members = protocol.composeTeam(branches);
+    assert.equal(members.length, 6);
+  });
+
+  it('does not duplicate agents already in branches', () => {
+    const branches = [
+      { id: 'impl', agent: 'elsabro-executor' },
+      { id: 'qa', agent: 'elsabro-qa' }
+    ];
+    const members = protocol.composeTeam(branches, 'implementation');
+    const agents = members.map(m => m.agent);
+    const unique = new Set(agents);
+    assert.equal(unique.size, agents.length, 'Duplicate agents found');
+  });
+
+  it('uses context-specific padding order', () => {
+    // For 'review' context, first padding agent should be verifier (since it's not in branches)
+    const branches = [
+      { id: 'a', agent: 'agent-a' },
+      { id: 'b', agent: 'agent-b' }
+    ];
+
+    const reviewMembers = protocol.composeTeam(branches, 'review');
+    // First padded member (index 2) should be verifier for review context
+    assert.equal(reviewMembers[2].agent, 'elsabro-verifier');
+    // Second padded member (index 3) should be qa for review context
+    assert.equal(reviewMembers[3].agent, 'elsabro-qa');
+
+    const fixMembers = protocol.composeTeam(branches, 'fix');
+    assert.equal(fixMembers[2].agent, 'elsabro-verifier');
+    assert.equal(fixMembers[3].agent, 'elsabro-qa');
+  });
+});
+
+// ---------- buildParallelInstruction ----------
+
+describe('CallbackProtocol: buildParallelInstruction', () => {
+  it('returns useAgentTeams=true for opus branches with 5+ team members', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'impl', agent: 'elsabro-executor', config: { model: 'opus' }, inputs: {} },
+      { id: 'test', agent: 'elsabro-qa', config: { model: 'opus' }, inputs: {} }
+    ];
+    const instr = protocol.buildParallelInstruction('parallel_impl', branches, { nodeContext: 'implementation' });
+
+    assert.equal(instr.type, 'parallel');
+    assert.equal(instr.useAgentTeams, true);
+    assert.ok(instr.team);
+    assert.ok(instr.team.members.length >= 5);
+    assert.ok(instr.team.name.startsWith('elsabro-'));
+  });
+
+  it('returns useAgentTeams=false for haiku branches with no team object', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'a', agent: 'Explore', config: { model: 'haiku' } },
+      { id: 'b', agent: 'Plan', config: { model: 'haiku' } }
+    ];
+    const instr = protocol.buildParallelInstruction('standard_analyze', branches);
+
+    assert.equal(instr.useAgentTeams, false);
+    assert.equal(instr.team, undefined);
+  });
+
+  it('team name follows convention', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'a', agent: 'x', config: { model: 'opus' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ];
+    const instr = protocol.buildParallelInstruction('fix_issues', branches, { taskSlug: 'auth bug' });
+    assert.ok(instr.team.name.startsWith('elsabro-'));
+    assert.ok(instr.team.name.length <= 38);
+  });
+
+  it('sets _activeTeam and _teamMembers', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'a', agent: 'x', config: { model: 'opus' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ];
+    protocol.buildParallelInstruction('test_node', branches);
+
+    assert.ok(protocol.hasActiveTeam());
+    assert.ok(protocol.getActiveTeam().startsWith('elsabro-'));
+    assert.ok(protocol.getTeamMembers().length >= 5);
+  });
+});
+
+// ---------- getLog + getTeamMembers ----------
+
+describe('CallbackProtocol: logging and state', () => {
+  it('records team_parallel log with member count', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'a', agent: 'x', config: { model: 'opus' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ];
+    protocol.buildParallelInstruction('node1', branches);
+
+    const log = protocol.getLog();
+    assert.equal(log.length, 1);
+    assert.equal(log[0].action, 'team_parallel');
+    assert.ok(log[0].memberCount >= 5);
+  });
+
+  it('getTeamMembers returns current roster', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'a', agent: 'x', config: { model: 'opus' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ];
+    protocol.buildParallelInstruction('node1', branches);
+
+    const members = protocol.getTeamMembers();
+    assert.ok(members.length >= 5);
+    assert.equal(members[0].agent, 'x');
+    assert.equal(members[1].agent, 'y');
+  });
+});
+
+// ---------- Other instruction builders ----------
+
+describe('CallbackProtocol: instruction builders', () => {
+  const protocol = new CallbackProtocol();
+
+  it('buildAgentInstruction has correct type and fields', () => {
+    const instr = protocol.buildAgentInstruction('node1', 'elsabro-executor', { model: 'opus' }, { task: 'foo' });
+    assert.equal(instr.type, 'agent');
+    assert.equal(instr.nodeId, 'node1');
+    assert.equal(instr.agent, 'elsabro-executor');
+    assert.equal(instr.model, 'opus');
+    assert.deepEqual(instr.inputs, { task: 'foo' });
+  });
+
+  it('buildInterruptInstruction has correct type and fields', () => {
+    const instr = protocol.buildInterruptInstruction('int1', { title: 'Test' }, { approve: 'next' }, 'reason');
+    assert.equal(instr.type, 'interrupt');
+    assert.equal(instr.nodeId, 'int1');
+    assert.deepEqual(instr.display, { title: 'Test' });
+    assert.deepEqual(instr.routes, { approve: 'next' });
+    assert.equal(instr.reason, 'reason');
+  });
+
+  it('buildSequenceInstruction has correct type and fields', () => {
+    const steps = [{ action: 'bash', command: 'echo hi' }];
+    const instr = protocol.buildSequenceInstruction('seq1', steps);
+    assert.equal(instr.type, 'sequence');
+    assert.equal(instr.nodeId, 'seq1');
+    assert.equal(instr.steps.length, 1);
+  });
+});
+
+// ---------- clearActiveTeam ----------
+
+describe('CallbackProtocol: clearActiveTeam', () => {
+  it('resets active team state', () => {
+    const protocol = new CallbackProtocol();
+    const branches = [
+      { id: 'a', agent: 'x', config: { model: 'opus' } },
+      { id: 'b', agent: 'y', config: { model: 'opus' } }
+    ];
+    protocol.buildParallelInstruction('node1', branches);
+    assert.ok(protocol.hasActiveTeam());
+
+    protocol.clearActiveTeam();
+    assert.equal(protocol.hasActiveTeam(), false);
+    assert.equal(protocol.getActiveTeam(), null);
+    assert.equal(protocol.getTeamMembers().length, 0);
+  });
+});

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

@@ -0,0 +1,208 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { main, parseArgs, flowIdFromPath, isAutoResolvable, detectNodeContext } = require('../src/cli');
+
+const FLOW_PATH = path.resolve(__dirname, '../../flows/development-flow.json');
+
+// Use a temp dir for checkpoints to avoid polluting project
+let tmpDir;
+let origCwd;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'elsabro-cli-test-'));
+  origCwd = process.cwd();
+  process.chdir(tmpDir);
+});
+
+afterEach(() => {
+  process.chdir(origCwd);
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+// ---------- Helpers ----------
+
+describe('CLI: helpers', () => {
+  it('parseArgs extracts command and flags', () => {
+    const { command, args } = parseArgs(['node', 'cli.js', 'validate', '--flow', 'test.json']);
+    assert.equal(command, 'validate');
+    assert.equal(args.flow, 'test.json');
+  });
+
+  it('flowIdFromPath generates valid id', () => {
+    assert.equal(flowIdFromPath('flows/development-flow.json'), 'development-flow');
+  });
+
+  it('detectNodeContext classifies node names', () => {
+    assert.equal(detectNodeContext('parallel_implementation'), 'implementation');
+    assert.equal(detectNodeContext('parallel_review'), 'review');
+    assert.equal(detectNodeContext('fix_issues'), 'fix');
+    assert.equal(detectNodeContext('some_node'), 'default');
+  });
+});
+
+// ---------- validate ----------
+
+describe('CLI: validate', () => {
+  it('reports valid flow with 42 nodes', async () => {
+    const result = await main(['node', 'cli.js', 'validate', '--flow', FLOW_PATH]);
+    assert.equal(result.valid, true);
+    assert.equal(result.nodeCount, 42);
+    assert.ok(result.parallelNodes.length >= 4);
+  });
+
+  it('parallel_implementation shows 5 team members', async () => {
+    const result = await main(['node', 'cli.js', 'validate', '--flow', FLOW_PATH]);
+    const implNode = result.parallelNodes.find(n => n.nodeId === 'parallel_implementation');
+    assert.ok(implNode, 'parallel_implementation not found');
+    assert.equal(implNode.useAgentTeams, true);
+    assert.equal(implNode.team.memberCount, 5);
+  });
+});
+
+// ---------- init + step + complete ----------
+
+describe('CLI: init + step + complete', () => {
+  it('init creates checkpoint and returns entryNode', async () => {
+    const result = await main(['node', 'cli.js', 'init', '--flow', FLOW_PATH, '--task', 'test task', '--profile', 'default']);
+    assert.equal(result.initialized, true);
+    assert.equal(result.entryNode, 'start');
+    assert.equal(result.task, 'test task');
+  });
+
+  it('step advances past entry to first actionable node', async () => {
+    // Init first
+    await main(['node', 'cli.js', 'init', '--flow', FLOW_PATH, '--task', 'build auth', '--profile', 'default']);
+
+    // Step
+    const result = await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+    assert.ok(!result.error, `Step errored: ${result.error}`);
+    // Should have advanced past entry + condition/router to an actionable node
+    assert.ok(result.instruction || result.finished, 'Expected instruction or finished');
+  });
+
+  it('complete accepts result and advances', async () => {
+    await main(['node', 'cli.js', 'init', '--flow', FLOW_PATH, '--task', 'test', '--profile', 'default']);
+    const stepResult = await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+
+    if (stepResult.instruction) {
+      const completeResult = await main([
+        'node', 'cli.js', 'complete', '--flow', FLOW_PATH,
+        '--result', JSON.stringify({ output: 'test result' })
+      ]);
+      assert.equal(completeResult.completed, true);
+      assert.ok(completeResult.nodeId);
+    }
+  });
+
+  it('subsequent step reaches next node', async () => {
+    await main(['node', 'cli.js', 'init', '--flow', FLOW_PATH, '--task', 'test', '--profile', 'default']);
+    const step1 = await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+
+    if (step1.instruction) {
+      await main([
+        'node', 'cli.js', 'complete', '--flow', FLOW_PATH,
+        '--result', JSON.stringify({ output: 'done' })
+      ]);
+
+      const step2 = await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+      assert.ok(step2.instruction || step2.finished, 'Expected instruction or finished');
+      // Should be a different node than step1 (or finished)
+      if (step2.instruction && step1.instruction) {
+        // They could be the same node if flow loops, but at least it advanced
+        assert.ok(step2.nodeId);
+      }
+    }
+  });
+});
+
+// ---------- status ----------
+
+describe('CLI: status', () => {
+  it('shows active session with nodesVisited', async () => {
+    await main(['node', 'cli.js', 'init', '--flow', FLOW_PATH, '--task', 'test', '--profile', 'default']);
+    await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+
+    const result = await main(['node', 'cli.js', 'status', '--flow', FLOW_PATH]);
+    assert.equal(result.active, true);
+    assert.ok(Array.isArray(result.nodesVisited));
+  });
+});
+
+// ---------- dry-run ----------
+
+describe('CLI: dry-run', () => {
+  it('completes a run and reports nodes visited', async () => {
+    const result = await main([
+      'node', 'cli.js', 'dry-run', '--flow', FLOW_PATH, '--task', 'test', '--profile', 'default'
+    ]);
+    assert.ok(!result.error, `Dry-run errored: ${result.error}`);
+    assert.equal(result.success, true);
+    assert.ok(result.nodesVisited.length > 5, 'Expected more than 5 nodes visited');
+  });
+
+  it('reports teamActions with 5+ members for non-haiku parallels', async () => {
+    const result = await main([
+      'node', 'cli.js', 'dry-run', '--flow', FLOW_PATH, '--task', 'test', '--profile', 'default'
+    ]);
+    // Should have team actions for parallel_implementation, fix_issues, parallel_review
+    if (result.teamActions && result.teamActions.length > 0) {
+      for (const ta of result.teamActions) {
+        assert.ok(ta.memberCount >= 5, `Team ${ta.teamName} has ${ta.memberCount} members, expected >= 5`);
+      }
+    }
+  });
+
+  it('visits profile-specific path nodes based on profile', async () => {
+    const result = await main([
+      'node', 'cli.js', 'dry-run', '--flow', FLOW_PATH, '--task', 'quick job', '--profile', 'yolo'
+    ]);
+    // Yolo profile should visit yolo-related nodes
+    assert.ok(result.nodesVisited.length > 3, 'Expected nodes to be visited');
+  });
+});
+
+// ---------- Edge cases ----------
+
+describe('CLI: edge cases', () => {
+  it('step with no checkpoint returns error', async () => {
+    const result = await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+    assert.ok(result.error);
+    assert.ok(result.error.includes('No checkpoint'));
+  });
+
+  it('complete with no checkpoint returns error', async () => {
+    const result = await main([
+      'node', 'cli.js', 'complete', '--flow', FLOW_PATH,
+      '--result', '{"ok": true}'
+    ]);
+    assert.ok(result.error);
+    assert.ok(result.error.includes('No checkpoint'));
+  });
+
+  it('double-complete returns error instead of corrupting state', async () => {
+    // init + step to reach an actionable node
+    await main(['node', 'cli.js', 'init', '--flow', FLOW_PATH, '--task', 'test', '--profile', 'default']);
+    const stepResult = await main(['node', 'cli.js', 'step', '--flow', FLOW_PATH]);
+    assert.ok(stepResult.instruction, 'Expected actionable instruction');
+
+    // First complete — should succeed
+    const first = await main([
+      'node', 'cli.js', 'complete', '--flow', FLOW_PATH,
+      '--result', '{"output": "done"}'
+    ]);
+    assert.ok(first.completed, 'First complete should succeed');
+
+    // Second complete on same node — should be rejected
+    const second = await main([
+      'node', 'cli.js', 'complete', '--flow', FLOW_PATH,
+      '--result', '{"output": "done again"}'
+    ]);
+    assert.ok(second.error, 'Double-complete should return error');
+    assert.ok(second.error.includes('already completed'), 'Error should mention already completed');
+  });
+});

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

@@ -7,7 +7,9 @@ const {
   executeParallel,
   executeInterrupt,
   executeTeam,
-  NotImplementedError
+  checkRuntimeStatus,
+  NotImplementedError,
+  DeprecatedNodeError
 } = require('../src/executors');
 
 function makeContext(overrides = {}) {
@@ -298,3 +300,61 @@ describe('executeTeam', () => {
     assert.equal(result.next, 'done');
   });
 });
+
+// ============================================================
+// P5: checkRuntimeStatus + DeprecatedNodeError
+// ============================================================
+
+describe('checkRuntimeStatus (P5)', () => {
+  it('throws NotImplementedError for not_implemented nodes', () => {
+    assert.throws(
+      () => checkRuntimeStatus({ id: 'test_node', runtime_status: 'not_implemented', gaps: ['test gap'] }),
+      (err) => {
+        assert.equal(err.name, 'NotImplementedError');
+        assert.equal(err.nodeId, 'test_node');
+        return true;
+      }
+    );
+  });
+
+  it('throws DeprecatedNodeError for deprecated nodes', () => {
+    assert.throws(
+      () => checkRuntimeStatus({ id: 'old_node', runtime_status: 'deprecated', deprecated_reason: 'Use new_node instead' }),
+      (err) => {
+        assert.equal(err.name, 'DeprecatedNodeError');
+        assert.equal(err.nodeId, 'old_node');
+        assert.equal(err.reason, 'Use new_node instead');
+        assert.ok(err.message.includes('deprecated'));
+        return true;
+      }
+    );
+  });
+
+  it('does not throw for implemented nodes', () => {
+    assert.doesNotThrow(
+      () => checkRuntimeStatus({ id: 'good_node', runtime_status: 'implemented' })
+    );
+  });
+
+  it('uses fallback reason when deprecated_reason is missing', () => {
+    assert.throws(
+      () => checkRuntimeStatus({ id: 'node_x', runtime_status: 'deprecated' }),
+      (err) => {
+        assert.equal(err.reason, 'Node is deprecated');
+        return true;
+      }
+    );
+  });
+});
+
+describe('DeprecatedNodeError properties', () => {
+  it('has correct name, nodeId, and reason', () => {
+    const err = new DeprecatedNodeError('my_node', 'superseded by v2');
+    assert.equal(err.name, 'DeprecatedNodeError');
+    assert.equal(err.nodeId, 'my_node');
+    assert.equal(err.reason, 'superseded by v2');
+    assert.ok(err.message.includes('my_node'));
+    assert.ok(err.message.includes('superseded by v2'));
+    assert.ok(err instanceof Error);
+  });
+});