@build-astron-co/nimbus 0.2.0

package/src/__tests__/circuit-breaker.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { ProviderCircuitBreaker } from '../llm/circuit-breaker';
+
+describe('ProviderCircuitBreaker', () => {
+  let breaker: ProviderCircuitBreaker;
+
+  beforeEach(() => {
+    breaker = new ProviderCircuitBreaker({ failureThreshold: 3, cooldownMs: 100 });
+  });
+
+  test('new provider is available (CLOSED)', () => {
+    expect(breaker.isAvailable('anthropic')).toBe(true);
+    expect(breaker.getState('anthropic')).toBe('CLOSED');
+  });
+
+  test('stays CLOSED below failure threshold', () => {
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    expect(breaker.isAvailable('anthropic')).toBe(true);
+    expect(breaker.getState('anthropic')).toBe('CLOSED');
+  });
+
+  test('opens circuit after reaching failure threshold', () => {
+    breaker.recordFailure('openai');
+    breaker.recordFailure('openai');
+    breaker.recordFailure('openai');
+    expect(breaker.isAvailable('openai')).toBe(false);
+    expect(breaker.getState('openai')).toBe('OPEN');
+  });
+
+  test('success resets circuit to CLOSED', () => {
+    breaker.recordFailure('google');
+    breaker.recordFailure('google');
+    breaker.recordSuccess('google');
+    expect(breaker.isAvailable('google')).toBe(true);
+    expect(breaker.getState('google')).toBe('CLOSED');
+  });
+
+  test('transitions to HALF_OPEN after cooldown', async () => {
+    breaker.recordFailure('bedrock');
+    breaker.recordFailure('bedrock');
+    breaker.recordFailure('bedrock');
+    expect(breaker.isAvailable('bedrock')).toBe(false);
+
+    // Wait for cooldown
+    await new Promise(r => setTimeout(r, 150));
+
+    expect(breaker.isAvailable('bedrock')).toBe(true);
+    expect(breaker.getState('bedrock')).toBe('HALF_OPEN');
+  });
+
+  test('success in HALF_OPEN returns to CLOSED', async () => {
+    breaker.recordFailure('ollama');
+    breaker.recordFailure('ollama');
+    breaker.recordFailure('ollama');
+
+    await new Promise(r => setTimeout(r, 150));
+
+    // Now HALF_OPEN
+    expect(breaker.isAvailable('ollama')).toBe(true);
+    breaker.recordSuccess('ollama');
+    expect(breaker.getState('ollama')).toBe('CLOSED');
+  });
+
+  test('failure in HALF_OPEN returns to OPEN', async () => {
+    breaker.recordFailure('groq');
+    breaker.recordFailure('groq');
+    breaker.recordFailure('groq');
+
+    await new Promise(r => setTimeout(r, 150));
+
+    // Transition to HALF_OPEN
+    expect(breaker.isAvailable('groq')).toBe(true);
+    breaker.recordFailure('groq');
+    expect(breaker.getState('groq')).toBe('OPEN');
+  });
+
+  test('independent circuits per provider', () => {
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    expect(breaker.isAvailable('anthropic')).toBe(false);
+    expect(breaker.isAvailable('openai')).toBe(true);
+  });
+
+  test('reset clears a single provider', () => {
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    breaker.reset('anthropic');
+    expect(breaker.isAvailable('anthropic')).toBe(true);
+    expect(breaker.getState('anthropic')).toBe('CLOSED');
+  });
+
+  test('resetAll clears all providers', () => {
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('anthropic');
+    breaker.recordFailure('openai');
+    breaker.recordFailure('openai');
+    breaker.recordFailure('openai');
+    breaker.resetAll();
+    expect(breaker.isAvailable('anthropic')).toBe(true);
+    expect(breaker.isAvailable('openai')).toBe(true);
+  });
+
+  test('default thresholds (5 failures, 60s cooldown)', () => {
+    const defaultBreaker = new ProviderCircuitBreaker();
+    for (let i = 0; i < 4; i++) {
+      defaultBreaker.recordFailure('test');
+    }
+    expect(defaultBreaker.isAvailable('test')).toBe(true);
+    defaultBreaker.recordFailure('test');
+    expect(defaultBreaker.isAvailable('test')).toBe(false);
+  });
+});

package/src/__tests__/cli-run.test.ts

@@ -0,0 +1,115 @@
+/**
+ * CLI Run Mode Tests
+ *
+ * Validates the parseRunArgs function that converts CLI arguments into
+ * structured RunOptions for the non-interactive nimbus run command.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { parseRunArgs } from '../cli/run';
+
+// ===========================================================================
+// parseRunArgs
+// ===========================================================================
+
+describe('parseRunArgs', () => {
+  test('parses prompt from positional args', () => {
+    const result = parseRunArgs(['deploy', 'staging', 'environment']);
+    expect(result.prompt).toBe('deploy staging environment');
+  });
+
+  test('parses --format json', () => {
+    const result = parseRunArgs(['--format', 'json', 'some', 'prompt']);
+    expect(result.format).toBe('json');
+    expect(result.prompt).toBe('some prompt');
+  });
+
+  test('parses --json shorthand', () => {
+    const result = parseRunArgs(['--json', 'prompt here']);
+    expect(result.format).toBe('json');
+  });
+
+  test('parses --auto-approve', () => {
+    const result = parseRunArgs(['--auto-approve', 'do', 'stuff']);
+    expect(result.autoApprove).toBe(true);
+  });
+
+  test('parses --stdin flag', () => {
+    const result = parseRunArgs(['--stdin']);
+    expect(result.stdin).toBe(true);
+  });
+
+  test('parses --model override', () => {
+    const result = parseRunArgs(['--model', 'anthropic/claude-haiku-4-5', 'prompt']);
+    expect(result.model).toBe('anthropic/claude-haiku-4-5');
+  });
+
+  test('parses --mode deploy', () => {
+    const result = parseRunArgs(['--mode', 'deploy', 'run', 'deployment']);
+    expect(result.mode).toBe('deploy');
+  });
+
+  test('parses --max-turns', () => {
+    const result = parseRunArgs(['--max-turns', '10', 'prompt']);
+    expect(result.maxTurns).toBe(10);
+  });
+
+  test('parses -y short form for auto-approve', () => {
+    const result = parseRunArgs(['-y', 'do', 'it']);
+    expect(result.autoApprove).toBe(true);
+    expect(result.prompt).toBe('do it');
+  });
+
+  test('handles empty args', () => {
+    const result = parseRunArgs([]);
+    expect(result.prompt).toBe('');
+    expect(result.format).toBe('text');
+    expect(result.autoApprove).toBe(false);
+    expect(result.stdin).toBe(false);
+    expect(result.model).toBeUndefined();
+    expect(result.mode).toBe('build');
+    expect(result.maxTurns).toBe(50);
+  });
+
+  test('joins multiple positional args as prompt', () => {
+    const result = parseRunArgs(['fix', 'the', 'failing', 'tests']);
+    expect(result.prompt).toBe('fix the failing tests');
+  });
+
+  test('default mode is "build"', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.mode).toBe('build');
+  });
+
+  test('default maxTurns is 50', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.maxTurns).toBe(50);
+  });
+
+  test('default format is "text"', () => {
+    const result = parseRunArgs(['prompt']);
+    expect(result.format).toBe('text');
+  });
+
+  test('combines multiple flags', () => {
+    const result = parseRunArgs([
+      '--format',
+      'json',
+      '--auto-approve',
+      '--mode',
+      'deploy',
+      '--max-turns',
+      '25',
+      '--model',
+      'openai/gpt-4',
+      'deploy',
+      'everything',
+    ]);
+    expect(result.format).toBe('json');
+    expect(result.autoApprove).toBe(true);
+    expect(result.mode).toBe('deploy');
+    expect(result.maxTurns).toBe(25);
+    expect(result.model).toBe('openai/gpt-4');
+    expect(result.prompt).toBe('deploy everything');
+  });
+});