anvil-dev-framework 0.1.6

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

@@ -0,0 +1,363 @@
+/**
+ * CCS Test Fixtures
+ *
+ * Mock data and fixtures for Context Checkpoint System (CCS) testing.
+ * Provides realistic Claude Code JSON input and Ralph state structures.
+ */
+
+/**
+ * Claude Code context window input structure
+ */
+export interface ContextWindowInput {
+  context_window: {
+    current_usage: {
+      input_tokens: number;
+      output_tokens: number;
+      cache_read_input_tokens: number;
+      cache_creation_input_tokens: number;
+    };
+    context_window_size: number;
+  };
+}
+
+/**
+ * Generate Claude Code JSON input with specified context percentage
+ *
+ * @param percent - Target context percentage (0-100)
+ * @param windowSize - Total context window size (default 200000)
+ */
+export function createContextInput(percent: number, windowSize = 200000): ContextWindowInput {
+  // Calculate tokens to achieve target percentage
+  // Context usage = input_tokens + cache_creation_input_tokens
+  const targetTokens = Math.floor((percent / 100) * windowSize);
+
+  // Split between input and cache write tokens
+  const inputTokens = Math.floor(targetTokens * 0.8);
+  const cacheWriteTokens = targetTokens - inputTokens;
+
+  return {
+    context_window: {
+      current_usage: {
+        input_tokens: inputTokens,
+        output_tokens: Math.floor(inputTokens * 0.3), // Output doesn't count toward limit
+        cache_read_input_tokens: Math.floor(inputTokens * 0.1), // Cache reads don't count
+        cache_creation_input_tokens: cacheWriteTokens,
+      },
+      context_window_size: windowSize,
+    },
+  };
+}
+
+/**
+ * Ralph state file structure
+ */
+/**
+ * File in progress entry for context checkpoint
+ */
+export interface FileInProgress {
+  path: string;
+  start_line?: number;
+  end_line?: number;
+}
+
+export interface RalphState {
+  iteration?: number;
+  started_at?: string;
+  status?: 'running' | 'completed' | 'max_iterations' | 'circuit_breaker' | 'fatal_error';
+  task_name?: string;
+  objective?: string;
+  todo_items?: string[];
+  completed_items?: string[];
+  no_change_count?: number;
+  last_diff_hash?: string;
+  error_hashes?: string[];
+  context_history?: Array<{
+    iteration: number;
+    peak_percent: number;
+    checkpoint: boolean;
+    level?: string;
+    timestamp?: string;
+  }>;
+  context_checkpoint?: {
+    active: boolean;
+    level: string;
+    percent_at_checkpoint: number;
+    timestamp: string;
+    handoff_file: string;
+    resume_summary: string;
+    files_in_progress: FileInProgress[];
+    current_todo_item: string;
+    progress_on_item: string;
+  };
+  linear_integration?: {
+    enabled: boolean;
+    parent_issue?: string;
+    no_sync?: boolean;
+    last_sync?: string;
+    subtasks?: Array<{
+      identifier: string;
+      title: string;
+      status: 'pending' | 'completed';
+      completed_at?: string;
+    }>;
+  };
+}
+
+/**
+ * Create a minimal Ralph state for testing
+ */
+export function createMinimalRalphState(overrides: Partial<RalphState> = {}): RalphState {
+  return {
+    iteration: 0,
+    started_at: new Date().toISOString(),
+    status: 'running',
+    no_change_count: 0,
+    last_diff_hash: '',
+    error_hashes: [],
+    ...overrides,
+  };
+}
+
+/**
+ * Create a full Ralph state with all fields
+ */
+export function createFullRalphState(overrides: Partial<RalphState> = {}): RalphState {
+  return {
+    iteration: 5,
+    started_at: new Date(Date.now() - 3600000).toISOString(), // 1 hour ago
+    status: 'running',
+    task_name: 'Implement ANV-204 CCS E2E Testing',
+    todo_items: [
+      'Create test infrastructure',
+      'Implement context monitor tests',
+      'Implement ralph stop tests',
+      'Implement integration tests',
+    ],
+    no_change_count: 0,
+    last_diff_hash: 'abc123',
+    error_hashes: [],
+    context_history: [
+      { iteration: 1, peak_percent: 25, checkpoint: false },
+      { iteration: 2, peak_percent: 45, checkpoint: false },
+      { iteration: 3, peak_percent: 55, checkpoint: false },
+      { iteration: 4, peak_percent: 62, checkpoint: false },
+      { iteration: 5, peak_percent: 68, checkpoint: false },
+    ],
+    ...overrides,
+  };
+}
+
+/**
+ * Create a Ralph state with an active checkpoint
+ */
+export function createCheckpointedState(
+  level: 'L2' | 'L3',
+  percent: number,
+  overrides: Partial<RalphState> = {}
+): RalphState {
+  const timestamp = new Date().toISOString();
+  const handoffFile = `.claude/handoffs/${new Date().toISOString().slice(0, 16).replace('T', '-').replace(':', '')}-checkpoint.md`;
+
+  return {
+    iteration: 10,
+    started_at: new Date(Date.now() - 7200000).toISOString(), // 2 hours ago
+    status: 'running',
+    task_name: 'Long Running Task',
+    todo_items: [
+      'Current task in progress',
+      'Next pending task',
+      'Another pending task',
+    ],
+    no_change_count: 0,
+    last_diff_hash: 'def456',
+    error_hashes: [],
+    context_history: [
+      { iteration: 8, peak_percent: 75, checkpoint: false },
+      { iteration: 9, peak_percent: 82, checkpoint: false },
+      { iteration: 10, peak_percent: percent, checkpoint: true, level, timestamp },
+    ],
+    context_checkpoint: {
+      active: true,
+      level,
+      percent_at_checkpoint: percent,
+      timestamp,
+      handoff_file: handoffFile,
+      resume_summary: '',
+      files_in_progress: [
+        { path: 'src/feature.ts', start_line: 10, end_line: 50 },
+        { path: 'src/feature.test.ts', start_line: 1, end_line: 100 },
+      ],
+      current_todo_item: 'Current task in progress',
+      progress_on_item: 'checkpoint triggered',
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Create a Ralph state with Linear integration
+ */
+export function createLinearIntegratedState(overrides: Partial<RalphState> = {}): RalphState {
+  return {
+    ...createFullRalphState(),
+    linear_integration: {
+      enabled: true,
+      parent_issue: 'ANV-204',
+      no_sync: false,
+      subtasks: [
+        { identifier: 'ANV-204-1', title: 'Phase 1: Setup', status: 'completed', completed_at: new Date(Date.now() - 1800000).toISOString() },
+        { identifier: 'ANV-204-2', title: 'Phase 2: Tests', status: 'pending' },
+        { identifier: 'ANV-204-3', title: 'Phase 3: Integration', status: 'pending' },
+      ],
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Create a Ralph state suitable for prompt generator testing
+ * Includes all fields expected by ralph_prompt_generator.py
+ */
+export function createPromptGeneratorState(overrides: Partial<RalphState> = {}): RalphState {
+  const timestamp = new Date().toISOString();
+  const handoffFile = `.claude/handoffs/${new Date().toISOString().slice(0, 16).replace('T', '-').replace(':', '')}-checkpoint.md`;
+
+  return {
+    iteration: 15,
+    started_at: new Date(Date.now() - 3600000).toISOString(),
+    status: 'running',
+    task_name: 'Implement Feature X',
+    objective: 'Complete the feature implementation with full test coverage',
+    todo_items: [
+      'Implement core logic',
+      'Add unit tests',
+      'Update documentation',
+    ],
+    completed_items: [
+      'Research requirements',
+      'Design architecture',
+      'Set up project structure',
+    ],
+    no_change_count: 0,
+    last_diff_hash: 'abc123',
+    error_hashes: [],
+    context_history: [
+      { iteration: 13, peak_percent: 80, checkpoint: false },
+      { iteration: 14, peak_percent: 87, checkpoint: false },
+      { iteration: 15, peak_percent: 92, checkpoint: true, level: 'L2', timestamp },
+    ],
+    context_checkpoint: {
+      active: true,
+      level: 'L2',
+      percent_at_checkpoint: 92,
+      timestamp,
+      handoff_file: handoffFile,
+      resume_summary: 'Implementing core feature logic',
+      files_in_progress: [
+        { path: 'src/feature.ts', start_line: 45, end_line: 120 },
+        { path: 'src/feature.test.ts', start_line: 1, end_line: 50 },
+      ],
+      current_todo_item: 'Implement core logic',
+      progress_on_item: 'Added base implementation, working on edge cases',
+    },
+    ...overrides,
+  };
+}
+
+// Pre-defined context inputs for each threshold level
+export const CONTEXT_INPUTS = {
+  /** L0: Normal operation (< 70%) */
+  L0_LOW: createContextInput(25),
+  L0_MEDIUM: createContextInput(50),
+  L0_HIGH: createContextInput(68),
+
+  /** L1: Warning zone (70-84%) */
+  L1_LOW: createContextInput(70),
+  L1_MEDIUM: createContextInput(77),
+  L1_HIGH: createContextInput(84),
+
+  /** L2: Checkpoint zone (85-94%) */
+  L2_LOW: createContextInput(85),
+  L2_MEDIUM: createContextInput(90),
+  L2_HIGH: createContextInput(94),
+
+  /** L3: Emergency zone (95%+) */
+  L3_LOW: createContextInput(95),
+  L3_MEDIUM: createContextInput(97),
+  L3_HIGH: createContextInput(99),
+};
+
+// Pre-defined Ralph states for common test scenarios
+export const RALPH_STATES = {
+  /** Fresh start state */
+  FRESH: createMinimalRalphState(),
+
+  /** Mid-session state */
+  RUNNING: createFullRalphState(),
+
+  /** With active L2 checkpoint */
+  CHECKPOINT_L2: createCheckpointedState('L2', 87),
+
+  /** With active L3 checkpoint */
+  CHECKPOINT_L3: createCheckpointedState('L3', 96),
+
+  /** With Linear integration */
+  WITH_LINEAR: createLinearIntegratedState(),
+
+  /** Near max iterations */
+  NEAR_MAX: createMinimalRalphState({ iteration: 48 }),
+
+  /** At circuit breaker threshold */
+  CIRCUIT_BREAKER: createMinimalRalphState({ no_change_count: 2 }),
+};
+
+/**
+ * Sample handoff document content
+ */
+export const SAMPLE_HANDOFF = `# Session Handoff
+
+## Summary
+Implementing ANV-204 CCS E2E Testing. Made progress on Phase 1 infrastructure.
+
+## Progress
+- [x] Created test-utils.ts
+- [x] Created fixtures.ts
+- [ ] Context monitor tests (in progress)
+- [ ] Ralph stop tests
+- [ ] Integration tests
+
+## Current State
+Working on context monitor threshold tests. Next step is L2 checkpoint scenarios.
+
+## Files Modified
+- global/tools/anvil-memory/src/__tests__/ccs/test-utils.ts
+- global/tools/anvil-memory/src/__tests__/ccs/fixtures.ts
+
+## Resume Instructions
+Continue from Phase 2: Context Monitor Hook Tests.
+`;
+
+/**
+ * Sample transcript with completion promise
+ */
+export const TRANSCRIPT_COMPLETE = `
+Working on the final task...
+All tests are passing now.
+<promise>COMPLETE</promise>
+`;
+
+/**
+ * Sample transcript with fatal error
+ */
+export const TRANSCRIPT_FATAL = `
+Encountered a critical issue...
+<fatal>Unable to proceed - missing required configuration</fatal>
+`;
+
+/**
+ * Sample transcript with stuck signals
+ */
+export const TRANSCRIPT_STUCK = `
+I'm stuck on this issue and cannot proceed without more information.
+The dependency seems to be blocked by an external factor.
+`;

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

@@ -0,0 +1,8 @@
+/**
+ * CCS Test Exports
+ *
+ * Re-exports all test utilities and fixtures for CCS testing.
+ */
+
+export * from './test-utils';
+export * from './fixtures';