anvil-dev-framework 0.1.6

package/global/tools/anvil-memory/src/__tests__/ccs/context-monitor.test.ts

@@ -0,0 +1,535 @@
+/**
+ * Context Monitor Hook Tests
+ *
+ * Tests for ralph_context_monitor.py threshold detection and state updates.
+ * Verifies L0-L3 threshold behavior, checkpoint triggering, and error handling.
+ */
+
+import { describe, test, expect, beforeEach, afterEach, beforeAll } from 'bun:test';
+import { join } from 'path';
+import {
+  TestStateManager,
+  runPythonHook,
+  isPython3Available,
+  HOOKS_DIR,
+} from './test-utils';
+import {
+  CONTEXT_INPUTS,
+  createMinimalRalphState,
+  createCheckpointedState,
+} from './fixtures';
+
+describe('Context Monitor Hook', () => {
+  let stateManager: TestStateManager;
+  let python3Available: boolean;
+
+  beforeAll(async () => {
+    python3Available = await isPython3Available();
+  });
+
+  beforeEach(() => {
+    stateManager = new TestStateManager('context-monitor');
+    stateManager.init();
+  });
+
+  afterEach(() => {
+    stateManager.cleanup();
+  });
+
+  describe('L0: Normal Operation (< 70%)', () => {
+    test('produces no output at low context', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      // Create Ralph state file to enable monitoring
+      stateManager.writeState(createMinimalRalphState({ iteration: 1 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_LOW,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe('');
+    });
+
+    test('updates context history without checkpoint', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 3 }));
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      const state = stateManager.readState();
+      const history = state.context_history as Array<{ iteration: number; peak_percent: number; checkpoint: boolean }>;
+
+      expect(history).toBeDefined();
+      expect(history.length).toBeGreaterThan(0);
+      expect(history[history.length - 1]!.checkpoint).toBe(false);
+    });
+
+    test('handles 68% context (just below L1)', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_HIGH,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).not.toContain('CCS_WARNING');
+      expect(result.stdout).not.toContain('CCS_CHECKPOINT');
+    });
+  });
+
+  describe('L1: Warning Zone (70-84%)', () => {
+    test('outputs warning at 70% threshold', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L1_LOW,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('CCS_WARNING');
+      expect(result.stdout).toContain('L1');
+      expect(result.stdout).toContain('70');
+    });
+
+    test('outputs warning at 77% (mid L1)', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 7 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L1_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('CCS_WARNING');
+      expect(result.stdout).toContain('L1');
+    });
+
+    test('updates history without triggering checkpoint', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 6 }));
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L1_HIGH,
+        { cwd: stateManager.baseDir }
+      );
+
+      const state = stateManager.readState();
+      expect(state.context_checkpoint).toBeUndefined();
+
+      const history = state.context_history as Array<{ checkpoint: boolean }>;
+      expect(history).toBeDefined();
+      expect(history[history.length - 1]!.checkpoint).toBe(false);
+    });
+  });
+
+  describe('L2: Checkpoint Zone (85-94%)', () => {
+    test('triggers checkpoint at 85% threshold', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 10 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L2_LOW,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0); // L2 doesn't exit with error
+      expect(result.stdout).toContain('CCS_CHECKPOINT_TRIGGERED');
+      expect(result.stdout).toContain('L2');
+      expect(result.stdout).toContain('85');
+    });
+
+    test('creates checkpoint state at 90%', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({
+        iteration: 12,
+        todo_items: ['Current task', 'Next task'],
+      }));
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L2_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      const state = stateManager.readState();
+      const checkpoint = state.context_checkpoint as Record<string, unknown>;
+
+      expect(checkpoint).toBeDefined();
+      expect(checkpoint.active).toBe(true);
+      expect(checkpoint.level).toBe('L2');
+      expect(checkpoint.percent_at_checkpoint).toBe(90);
+      expect(checkpoint.handoff_file).toContain('.claude/handoffs/');
+      expect(checkpoint.current_todo_item).toBe('Current task');
+    });
+
+    test('updates context history with checkpoint flag', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 15 }));
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L2_HIGH,
+        { cwd: stateManager.baseDir }
+      );
+
+      const state = stateManager.readState();
+      const history = state.context_history as Array<{
+        checkpoint: boolean;
+        level: string;
+        iteration: number;
+      }>;
+
+      expect(history).toBeDefined();
+      const lastEntry = history[history.length - 1]!;
+      expect(lastEntry.checkpoint).toBe(true);
+      expect(lastEntry.level).toBe('L2');
+    });
+  });
+
+  describe('L3: Emergency Zone (95%+)', () => {
+    test('triggers emergency stop at 95%', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 20 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L3_LOW,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(1); // L3 exits with error
+      expect(result.stdout).toContain('CCS_EMERGENCY_STOP');
+      expect(result.stdout).toContain('L3');
+      expect(result.stdout).toContain('95');
+    });
+
+    test('triggers emergency stop at 99%', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 25 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L3_HIGH,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout).toContain('CCS_EMERGENCY_STOP');
+      expect(result.stdout).toContain('L3');
+    });
+
+    test('creates L3 checkpoint state', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 30 }));
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L3_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      const state = stateManager.readState();
+      const checkpoint = state.context_checkpoint as Record<string, unknown>;
+
+      expect(checkpoint).toBeDefined();
+      expect(checkpoint.active).toBe(true);
+      expect(checkpoint.level).toBe('L3');
+    });
+  });
+
+  describe('Checkpoint Already Active', () => {
+    test('does not re-trigger when checkpoint is active', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      // Create state with active checkpoint
+      stateManager.writeState(createCheckpointedState('L2', 87));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L2_HIGH, // Would normally trigger checkpoint
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe(''); // No output when checkpoint already active
+    });
+
+    test('does not upgrade L2 to L3 when checkpoint active', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      // Create state with active L2 checkpoint
+      stateManager.writeState(createCheckpointedState('L2', 87));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L3_LOW, // Would normally trigger L3
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0); // Should not exit with error
+      expect(result.stdout).not.toContain('CCS_EMERGENCY_STOP');
+
+      // Checkpoint should still be L2
+      const state = stateManager.readState();
+      const checkpoint = state.context_checkpoint as Record<string, unknown>;
+      expect(checkpoint.level).toBe('L2');
+    });
+  });
+
+  describe('Non-Ralph Mode (No State File)', () => {
+    test('exits silently without state file', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      // Don't create any state file
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L3_HIGH, // Would trigger emergency if active
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe('');
+    });
+
+    test('does not create state file', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L2_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(stateManager.stateExists()).toBe(false);
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('handles malformed JSON input gracefully', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      const hookPath = join(HOOKS_DIR, 'ralph_context_monitor.py');
+      const proc = Bun.spawn(['python3', hookPath], {
+        stdin: new Blob(['not valid json at all']),
+        stdout: 'pipe',
+        stderr: 'pipe',
+        cwd: stateManager.baseDir,
+      });
+
+      const stdout = await new Response(proc.stdout).text();
+      await proc.exited;
+
+      expect(proc.exitCode).toBe(0); // Should not crash
+      expect(stdout.trim()).toBe(''); // No output on error
+    });
+
+    test('handles empty input gracefully', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      const hookPath = join(HOOKS_DIR, 'ralph_context_monitor.py');
+      const proc = Bun.spawn(['python3', hookPath], {
+        stdin: new Blob(['']),
+        stdout: 'pipe',
+        stderr: 'pipe',
+        cwd: stateManager.baseDir,
+      });
+
+      await proc.exited;
+      expect(proc.exitCode).toBe(0);
+    });
+
+    test('handles missing context_window gracefully', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        { some_other_field: 'value' },
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+      // Should calculate 0% and produce no output
+      expect(result.stdout).toBe('');
+    });
+
+    test('handles zero context_window_size gracefully', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      const result = await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        {
+          context_window: {
+            current_usage: { input_tokens: 100 },
+            context_window_size: 0, // Would cause division by zero
+          },
+        },
+        { cwd: stateManager.baseDir }
+      );
+
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('Context History Accumulation', () => {
+    test('accumulates history across multiple calls', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      // Start with iteration 1
+      stateManager.writeState(createMinimalRalphState({ iteration: 1 }));
+
+      // First call at 30%
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_LOW,
+        { cwd: stateManager.baseDir }
+      );
+
+      // Update iteration and call again at 50%
+      const state1 = stateManager.readState();
+      stateManager.writeState({ ...state1, iteration: 2 });
+
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      // Check history has both entries
+      const finalState = stateManager.readState();
+      const history = finalState.context_history as Array<{ iteration: number }>;
+
+      expect(history.length).toBe(2);
+      expect(history[0]!.iteration).toBe(1);
+      expect(history[1]!.iteration).toBe(2);
+    });
+
+    test('updates peak_percent for same iteration', async () => {
+      if (!python3Available) {
+        console.log('Skipping: Python 3 not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 5 }));
+
+      // First call at 30%
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_LOW,
+        { cwd: stateManager.baseDir }
+      );
+
+      // Second call at 50% (same iteration)
+      await runPythonHook(
+        join(HOOKS_DIR, 'ralph_context_monitor.py'),
+        CONTEXT_INPUTS.L0_MEDIUM,
+        { cwd: stateManager.baseDir }
+      );
+
+      const state = stateManager.readState();
+      const history = state.context_history as Array<{ peak_percent: number }>;
+
+      // Should have only one entry with the higher peak
+      expect(history.length).toBe(1);
+      expect(history[0]!.peak_percent).toBe(50);
+    });
+  });
+});