anvil-dev-framework 0.1.6

package/global/tools/anvil-memory/src/__tests__/ccs/edge-cases.test.ts

@@ -0,0 +1,645 @@
+/**
+ * CCS Edge Cases and Performance Tests
+ *
+ * Tests for boundary conditions, edge cases, and performance benchmarks
+ * for the Context Checkpoint System.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import {
+  TestStateManager,
+  runContextMonitor,
+  runRalphStop,
+  runPythonHook,
+  isJqAvailable,
+  isPythonAvailable,
+  LIB_DIR,
+} from './test-utils';
+import {
+  createMinimalRalphState,
+  createFullRalphState,
+  createContextInput,
+} from './fixtures';
+import type { RalphState } from './fixtures';
+import { join } from 'path';
+
+const PROMPT_GENERATOR_PATH = join(LIB_DIR, 'ralph_prompt_generator.py');
+
+describe('CCS Edge Cases', () => {
+  let stateManager: TestStateManager;
+  let pythonAvailable: boolean;
+  let jqAvailable: boolean;
+
+  beforeEach(async () => {
+    stateManager = new TestStateManager('ccs-edge');
+    stateManager.init();
+    [pythonAvailable, jqAvailable] = await Promise.all([
+      isPythonAvailable(),
+      isJqAvailable(),
+    ]);
+  });
+
+  afterEach(() => {
+    stateManager.cleanup();
+  });
+
+  describe('Boundary Percentages', () => {
+    test('exactly 70% triggers L1 (boundary)', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(70);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('L1');
+    });
+
+    test('exactly 85% triggers L2 (boundary)', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(85);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('L2');
+    });
+
+    test('exactly 95% triggers L3 (boundary)', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(95);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      // L3 exits with code 1 for emergency
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout).toContain('L3');
+    });
+
+    test('69.9% stays in L0', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(69.9);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+      // L0 may be silent (no output needed) - just verify no L1/L2/L3
+      expect(result.stdout).not.toContain('L1');
+      expect(result.stdout).not.toContain('L2');
+      expect(result.stdout).not.toContain('L3');
+    });
+
+    test('84.9% stays in L1', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(84.9);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('L1');
+    });
+
+    test('94.9% stays in L2', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(94.9);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('L2');
+    });
+
+    test('100% context is handled', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(100);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      // Should still process (L3)
+      expect(typeof result.exitCode).toBe('number');
+    });
+
+    test('0% context is handled', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(0);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+      // L0 may be silent - just verify no warnings triggered
+      expect(result.stdout).not.toContain('L1');
+      expect(result.stdout).not.toContain('L2');
+      expect(result.stdout).not.toContain('L3');
+    });
+  });
+
+  describe('Empty and Minimal States', () => {
+    test('handles completely empty state file', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState({});
+      const input = createContextInput(50);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      // Should not crash
+      expect(typeof result.exitCode).toBe('number');
+    });
+
+    test('handles state with only iteration', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState({ iteration: 1 });
+      const input = createContextInput(50);
+
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    test('prompt generator handles empty checkpoint', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState({
+        context_checkpoint: {},
+      });
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      // Should not crash, generates with defaults
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('Large Data Sets', () => {
+    test('handles very long todo list (100 items)', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const manyTodos = Array.from({ length: 100 }, (_, i) => `Todo item ${i + 1}`);
+      const state = createFullRalphState({
+        todo_items: manyTodos,
+      });
+      stateManager.writeState(state);
+
+      const input = createContextInput(50);
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    test('handles large context history (1000 entries)', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const largeHistory = Array.from({ length: 1000 }, (_, i) => ({
+        iteration: i + 1,
+        peak_percent: Math.random() * 100,
+        checkpoint: i % 50 === 0,
+      }));
+
+      const state = createFullRalphState({
+        context_history: largeHistory,
+      });
+      stateManager.writeState(state);
+
+      const input = createContextInput(50);
+      const result = await runContextMonitor(input, stateManager);
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    test('prompt generator handles many completed items', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const manyCompleted = Array.from({ length: 50 }, (_, i) => `Completed item ${i + 1}`);
+      const state = createFullRalphState({
+        completed_items: manyCompleted,
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 87,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: '',
+          files_in_progress: [],
+          current_todo_item: 'Current',
+          progress_on_item: '',
+        },
+      });
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      // Should truncate and show "earlier items"
+      expect(result.stdout).toContain('earlier items');
+    });
+  });
+
+  describe('Special Characters', () => {
+    test('handles unicode in task name', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createFullRalphState({
+        task_name: 'Implement 日本語 feature with émojis 🎉',
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 87,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: '',
+          files_in_progress: [],
+          current_todo_item: 'Unicode task 中文',
+          progress_on_item: '',
+        },
+      });
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('日本語');
+    });
+
+    test('handles special chars in file paths', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createFullRalphState({
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 87,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: '',
+          files_in_progress: [
+            { path: 'src/components/My Component.tsx', start_line: 1, end_line: 10 },
+            { path: 'src/utils/helpers-v2.0.ts', start_line: 1, end_line: 20 },
+          ],
+          current_todo_item: '',
+          progress_on_item: '',
+        },
+      });
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('My Component.tsx');
+    });
+
+    test('handles quotes in todo items', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createFullRalphState({
+        todo_items: [
+          'Fix "double quotes" issue',
+          "Handle 'single quotes' correctly",
+          'Mixed "quotes" and \'apostrophes\'',
+        ],
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 87,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: '',
+          files_in_progress: [],
+          current_todo_item: 'Fix "double quotes" issue',
+          progress_on_item: '',
+        },
+      });
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('Max Iterations Edge Cases', () => {
+    test('handles iteration at exact max', async () => {
+      if (!jqAvailable) {
+        console.log('Skipping: jq not available');
+        return;
+      }
+
+      // Iteration 49, max 50 - should exit at 50
+      stateManager.writeState(createMinimalRalphState({ iteration: 49 }));
+
+      const result = await runRalphStop(stateManager, { maxIterations: 50 });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stderr).toContain('Maximum');
+    });
+
+    test('handles iteration one below max', async () => {
+      if (!jqAvailable) {
+        console.log('Skipping: jq not available');
+        return;
+      }
+
+      // Iteration 48, max 50 - should continue
+      stateManager.writeState(createMinimalRalphState({ iteration: 48 }));
+
+      const result = await runRalphStop(stateManager, { maxIterations: 50 });
+
+      expect(result.exitCode).toBe(1); // Continue
+    });
+
+    test('handles very high max iterations', async () => {
+      if (!jqAvailable) {
+        console.log('Skipping: jq not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 100 }));
+
+      const result = await runRalphStop(stateManager, { maxIterations: 1000 });
+
+      expect(result.exitCode).toBe(1); // Continue
+    });
+
+    test('handles max iterations = 1', async () => {
+      if (!jqAvailable) {
+        console.log('Skipping: jq not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState({ iteration: 0 }));
+
+      const result = await runRalphStop(stateManager, { maxIterations: 1 });
+
+      expect(result.exitCode).toBe(0); // Max reached
+    });
+  });
+
+  describe('Invalid Input Handling', () => {
+    test('context monitor handles malformed JSON input', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+
+      // Send malformed input directly
+      const proc = Bun.spawn(['python3', join(stateManager.baseDir, '../../..', 'global/hooks/ralph_context_monitor.py')], {
+        stdin: new Blob(['not valid json']),
+        stdout: 'pipe',
+        stderr: 'pipe',
+        cwd: stateManager.baseDir,
+      });
+
+      await proc.exited;
+
+      // Should handle gracefully (might exit 0 or 1, but shouldn't crash)
+      expect(typeof proc.exitCode).toBe('number');
+    });
+
+    test('context monitor handles missing context_window field', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+
+      const proc = Bun.spawn(['python3', join(stateManager.baseDir, '../../..', 'global/hooks/ralph_context_monitor.py')], {
+        stdin: new Blob([JSON.stringify({ some_other_field: 123 })]),
+        stdout: 'pipe',
+        stderr: 'pipe',
+        cwd: stateManager.baseDir,
+      });
+
+      await proc.exited;
+
+      // Should handle gracefully
+      expect(typeof proc.exitCode).toBe('number');
+    });
+  });
+});
+
+describe('CCS Performance', () => {
+  let stateManager: TestStateManager;
+  let pythonAvailable: boolean;
+
+  beforeEach(async () => {
+    stateManager = new TestStateManager('ccs-perf');
+    stateManager.init();
+    pythonAvailable = await isPythonAvailable();
+  });
+
+  afterEach(() => {
+    stateManager.cleanup();
+  });
+
+  describe('Response Time', () => {
+    test('context monitor responds within 500ms', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createFullRalphState());
+      const input = createContextInput(50);
+
+      const start = performance.now();
+      await runContextMonitor(input, stateManager);
+      const elapsed = performance.now() - start;
+
+      expect(elapsed).toBeLessThan(500);
+      console.log(`  Context monitor response: ${elapsed.toFixed(2)}ms`);
+    });
+
+    test('prompt generator responds within 500ms', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createFullRalphState({
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 87,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: '',
+          files_in_progress: [{ path: 'test.ts', start_line: 1, end_line: 100 }],
+          current_todo_item: 'Test',
+          progress_on_item: '',
+        },
+      });
+      stateManager.writeState(state);
+
+      const start = performance.now();
+      await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+      const elapsed = performance.now() - start;
+
+      expect(elapsed).toBeLessThan(500);
+      console.log(`  Prompt generator response: ${elapsed.toFixed(2)}ms`);
+    });
+
+    test('large history does not significantly impact performance', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      // Create state with large history
+      const largeHistory = Array.from({ length: 500 }, (_, i) => ({
+        iteration: i + 1,
+        peak_percent: Math.random() * 100,
+        checkpoint: i % 50 === 0,
+      }));
+
+      const state = createFullRalphState({
+        context_history: largeHistory,
+      });
+      stateManager.writeState(state);
+
+      const input = createContextInput(50);
+
+      const start = performance.now();
+      await runContextMonitor(input, stateManager);
+      const elapsed = performance.now() - start;
+
+      expect(elapsed).toBeLessThan(1000);
+      console.log(`  Large history (500 entries) response: ${elapsed.toFixed(2)}ms`);
+    });
+  });
+
+  describe('Throughput', () => {
+    test('can process multiple L0 checks quickly', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      stateManager.writeState(createMinimalRalphState());
+      const input = createContextInput(30);
+
+      const iterations = 5;
+      const start = performance.now();
+
+      for (let i = 0; i < iterations; i++) {
+        await runContextMonitor(input, stateManager);
+      }
+
+      const elapsed = performance.now() - start;
+      const avgTime = elapsed / iterations;
+
+      expect(avgTime).toBeLessThan(200);
+      console.log(`  Average L0 check time: ${avgTime.toFixed(2)}ms (${iterations} iterations)`);
+    });
+  });
+});