anvil-dev-framework 0.1.6

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

@@ -0,0 +1,417 @@
+/**
+ * CCS Integration Tests
+ *
+ * Tests for the full Context Checkpoint System workflow:
+ * Context Monitor → Checkpoint → Ralph Stop → Prompt Generator
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import {
+  TestStateManager,
+  runContextMonitor,
+  runRalphStop,
+  runPythonHook,
+  isJqAvailable,
+  isPythonAvailable,
+  LIB_DIR,
+} from './test-utils';
+import {
+  createMinimalRalphState,
+  createFullRalphState,
+  CONTEXT_INPUTS,
+} from './fixtures';
+
+const PROMPT_GENERATOR_PATH = join(LIB_DIR, 'ralph_prompt_generator.py');
+
+describe('CCS Integration', () => {
+  let stateManager: TestStateManager;
+  let jqAvailable: boolean;
+  let pythonAvailable: boolean;
+
+  beforeEach(async () => {
+    stateManager = new TestStateManager('ccs-integration');
+    stateManager.init();
+    [jqAvailable, pythonAvailable] = await Promise.all([
+      isJqAvailable(),
+      isPythonAvailable(),
+    ]);
+  });
+
+  afterEach(() => {
+    stateManager.cleanup();
+  });
+
+  describe('Checkpoint Creation Flow', () => {
+    test('L2 context triggers checkpoint creation in state', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      // Setup: Ralph state without checkpoint
+      const initialState = createFullRalphState({
+        context_checkpoint: undefined,
+      });
+      stateManager.writeState(initialState);
+
+      // Act: Run context monitor with L2 context
+      const result = await runContextMonitor(CONTEXT_INPUTS.L2_MEDIUM, stateManager);
+
+      // Verify: Monitor detected L2
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('L2');
+
+      // Verify: State now has checkpoint
+      const finalState = stateManager.readState();
+      expect(finalState.context_checkpoint).toBeDefined();
+      if (finalState.context_checkpoint) {
+        const checkpoint = finalState.context_checkpoint as Record<string, unknown>;
+        expect(checkpoint.active).toBe(true);
+        expect(checkpoint.level).toBe('L2');
+      }
+    });
+
+    test('L3 context triggers emergency checkpoint', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const initialState = createFullRalphState({
+        task_name: 'Emergency Test Task',
+        todo_items: ['Urgent item'],
+      });
+      stateManager.writeState(initialState);
+
+      const result = await runContextMonitor(CONTEXT_INPUTS.L3_MEDIUM, stateManager);
+
+      // L3 exits with code 1 to signal emergency stop
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout).toContain('L3');
+
+      const finalState = stateManager.readState();
+      expect(finalState.context_checkpoint).toBeDefined();
+      if (finalState.context_checkpoint) {
+        const checkpoint = finalState.context_checkpoint as Record<string, unknown>;
+        expect(checkpoint.level).toBe('L3');
+      }
+    });
+
+    test('handoff file is referenced in checkpoint', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const initialState = createFullRalphState();
+      stateManager.writeState(initialState);
+
+      await runContextMonitor(CONTEXT_INPUTS.L2_LOW, stateManager);
+
+      const finalState = stateManager.readState();
+      if (finalState.context_checkpoint) {
+        const checkpoint = finalState.context_checkpoint as Record<string, unknown>;
+        expect(checkpoint.handoff_file).toBeDefined();
+        expect(typeof checkpoint.handoff_file).toBe('string');
+        expect((checkpoint.handoff_file as string)).toContain('.claude/handoffs/');
+      }
+    });
+  });
+
+  describe('Ralph Stop Checkpoint Detection', () => {
+    test('ralph stop detects active checkpoint and restarts', async () => {
+      if (!jqAvailable) {
+        console.log('Skipping: jq not available');
+        return;
+      }
+
+      // Setup: Create state with active checkpoint
+      const stateWithCheckpoint = createFullRalphState({
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 87,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: 'Test resume',
+          files_in_progress: [{ path: 'test.ts', start_line: 1, end_line: 10 }],
+          current_todo_item: 'Current task',
+          progress_on_item: 'In progress',
+        },
+      });
+      stateManager.writeState(stateWithCheckpoint);
+
+      // Act: Run ralph stop
+      const result = await runRalphStop(stateManager);
+
+      // Verify: Should restart loop (exit 1) due to checkpoint
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('checkpoint');
+    });
+
+    test('ralph stop continues without checkpoint', async () => {
+      if (!jqAvailable) {
+        console.log('Skipping: jq not available');
+        return;
+      }
+
+      const stateNoCheckpoint = createMinimalRalphState({ iteration: 5 });
+      stateManager.writeState(stateNoCheckpoint);
+
+      const result = await runRalphStop(stateManager);
+
+      // Should restart loop normally
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe('Prompt Generator Integration', () => {
+    test('prompt generator reads checkpoint state correctly', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      // Setup: First create checkpoint via context monitor
+      const initialState = createFullRalphState({
+        task_name: 'Integration Test Task',
+        objective: 'Complete the integration',
+        todo_items: ['Step 1', 'Step 2', 'Step 3'],
+        completed_items: ['Setup'],
+      });
+      stateManager.writeState(initialState);
+
+      // Trigger checkpoint
+      await runContextMonitor(CONTEXT_INPUTS.L2_HIGH, stateManager);
+
+      // Now generate prompt from checkpointed 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('Integration Test Task');
+      expect(result.stdout).toContain('L2');
+      expect(result.stdout).toContain('Step 1');
+    });
+
+    test('prompt generator writes valid PROMPT.md', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createFullRalphState({
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 89,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/session.md',
+          resume_summary: '',
+          files_in_progress: [{ path: 'main.ts', start_line: 100, end_line: 200 }],
+          current_todo_item: 'Current work',
+          progress_on_item: 'Halfway done',
+        },
+      });
+      stateManager.writeState(state);
+
+      const promptPath = join(stateManager.baseDir, 'PROMPT.md');
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--output', promptPath],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(promptPath)).toBe(true);
+
+      const promptContent = readFileSync(promptPath, 'utf-8');
+      expect(promptContent).toContain('Session Resume');
+      expect(promptContent).toContain('Resume Instructions');
+      expect(promptContent).toContain('main.ts');
+    });
+  });
+
+  describe('Full Cycle Test', () => {
+    test('complete checkpoint → resume cycle', async () => {
+      if (!pythonAvailable || !jqAvailable) {
+        console.log('Skipping: Dependencies not available');
+        return;
+      }
+
+      // Step 1: Initial state - running task
+      const initialState = createFullRalphState({
+        iteration: 10,
+        task_name: 'Full Cycle Test',
+        objective: 'Test complete CCS workflow',
+        todo_items: ['Remaining item 1', 'Remaining item 2'],
+        completed_items: ['Completed item 1'],
+      });
+      stateManager.writeState(initialState);
+
+      // Step 2: Context monitor detects high usage and creates checkpoint
+      const monitorResult = await runContextMonitor(CONTEXT_INPUTS.L2_MEDIUM, stateManager);
+      expect(monitorResult.exitCode).toBe(0);
+
+      // Verify checkpoint was created
+      const stateAfterMonitor = stateManager.readState();
+      expect(stateAfterMonitor.context_checkpoint).toBeDefined();
+      const checkpoint = stateAfterMonitor.context_checkpoint as Record<string, unknown>;
+      expect(checkpoint.active).toBe(true);
+
+      // Step 3: Ralph stop detects checkpoint and signals restart
+      const stopResult = await runRalphStop(stateManager);
+      expect(stopResult.exitCode).toBe(1); // Restart loop
+
+      // Step 4: Generate resume prompt
+      const promptPath = join(stateManager.baseDir, 'PROMPT.md');
+      const promptResult = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--output', promptPath],
+        }
+      );
+      expect(promptResult.exitCode).toBe(0);
+
+      // Step 5: Validate generated prompt
+      expect(existsSync(promptPath)).toBe(true);
+      const promptContent = readFileSync(promptPath, 'utf-8');
+      expect(promptContent).toContain('Full Cycle Test');
+      expect(promptContent).toContain('Resume Instructions');
+      expect(promptContent).toContain('L2');
+      expect(promptContent).toContain('Remaining item 1');
+    });
+  });
+
+  describe('Context History Tracking', () => {
+    test('context history accumulates across iterations', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const initialState = createMinimalRalphState({
+        iteration: 1,
+        context_history: [],
+      });
+      stateManager.writeState(initialState);
+
+      // Run several context monitor calls at different levels
+      await runContextMonitor(CONTEXT_INPUTS.L0_MEDIUM, stateManager);
+
+      // Update iteration and run again
+      const state1 = stateManager.readState();
+      stateManager.writeState({ ...state1, iteration: 2 });
+      await runContextMonitor(CONTEXT_INPUTS.L1_LOW, stateManager);
+
+      // Final check
+      const finalState = stateManager.readState();
+      const history = finalState.context_history as Array<Record<string, unknown>> | undefined;
+
+      // History should have entries
+      expect(history).toBeDefined();
+      if (history) {
+        expect(history.length).toBeGreaterThan(0);
+      }
+    });
+
+    test('checkpoint event is recorded in history', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const initialState = createFullRalphState({
+        context_history: [
+          { iteration: 1, peak_percent: 30, checkpoint: false },
+          { iteration: 2, peak_percent: 50, checkpoint: false },
+        ],
+      });
+      stateManager.writeState(initialState);
+
+      // Trigger checkpoint
+      await runContextMonitor(CONTEXT_INPUTS.L2_MEDIUM, stateManager);
+
+      const finalState = stateManager.readState();
+      const history = finalState.context_history as Array<Record<string, unknown>> | undefined;
+
+      if (history) {
+        // Find checkpoint entry
+        const checkpointEntry = history.find(h => h.checkpoint === true);
+        expect(checkpointEntry).toBeDefined();
+        if (checkpointEntry) {
+          expect(checkpointEntry.level).toBe('L2');
+        }
+      }
+    });
+  });
+
+  describe('Error Recovery', () => {
+    test('system handles missing handoff directory gracefully', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      // Create state but remove handoffs directory
+      const state = createFullRalphState();
+      stateManager.writeState(state);
+
+      // This should still work - context monitor should create directory if needed
+      const result = await runContextMonitor(CONTEXT_INPUTS.L2_LOW, stateManager);
+
+      // Should not crash
+      expect(typeof result.exitCode).toBe('number');
+    });
+
+    test('system handles sequential state modifications', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createFullRalphState();
+      stateManager.writeState(state);
+
+      // Run monitors sequentially (concurrent writes are a known race condition)
+      const result1 = await runContextMonitor(CONTEXT_INPUTS.L1_LOW, stateManager);
+      const result2 = await runContextMonitor(CONTEXT_INPUTS.L1_MEDIUM, stateManager);
+
+      // Both should complete without crashing
+      expect(typeof result1.exitCode).toBe('number');
+      expect(typeof result2.exitCode).toBe('number');
+
+      // State should still be valid JSON
+      const finalState = stateManager.readState();
+      expect(finalState).toBeDefined();
+      expect(finalState.context_history).toBeDefined();
+    });
+  });
+});
+
+describe('CCS Integration - Dependency Check', () => {
+  test('all required hook scripts exist', () => {
+    const hookPaths = [
+      '/Users/alexandercahiz/Projects/anvil-dev-framework/global/hooks/ralph_context_monitor.py',
+      '/Users/alexandercahiz/Projects/anvil-dev-framework/global/hooks/ralph_stop.sh',
+      '/Users/alexandercahiz/Projects/anvil-dev-framework/global/lib/ralph_prompt_generator.py',
+    ];
+
+    for (const hookPath of hookPaths) {
+      expect(existsSync(hookPath)).toBe(true);
+    }
+  });
+});