anvil-dev-framework 0.1.6

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

@@ -0,0 +1,571 @@
+/**
+ * Prompt Generator Tests
+ *
+ * Tests for ralph_prompt_generator.py resume template generation.
+ * Verifies PROMPT.md creation for Ralph and Manual resume modes.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { existsSync } from 'fs';
+import {
+  TestStateManager,
+  runPythonHook,
+  isPythonAvailable,
+} from './test-utils';
+import {
+  createPromptGeneratorState,
+  createCheckpointedState,
+  createMinimalRalphState,
+  SAMPLE_HANDOFF,
+} from './fixtures';
+
+const PROMPT_GENERATOR_PATH = '/Users/alexandercahiz/Projects/anvil-dev-framework/global/lib/ralph_prompt_generator.py';
+
+describe('Prompt Generator', () => {
+  let stateManager: TestStateManager;
+  let pythonAvailable: boolean;
+
+  beforeEach(async () => {
+    stateManager = new TestStateManager('prompt-generator');
+    stateManager.init();
+    pythonAvailable = await isPythonAvailable();
+  });
+
+  afterEach(() => {
+    stateManager.cleanup();
+  });
+
+  describe('State File Mode', () => {
+    test('generates resume prompt from state file', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      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('Session Resume');
+      expect(result.stdout).toContain('L2');
+      expect(result.stdout).toContain('Implement Feature X');
+    });
+
+    test('includes checkpoint header with level and percentage', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createCheckpointedState('L3', 96);
+      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('L3');
+      expect(result.stdout).toContain('96%');
+    });
+
+    test('includes session summary with progress', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState({
+        task_name: 'Test Task',
+        objective: 'Test objective description',
+        iteration: 20,
+        completed_items: ['Item 1', 'Item 2', 'Item 3'],
+        todo_items: ['Item 4', 'Item 5'],
+      });
+      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 Task');
+      expect(result.stdout).toContain('Test objective description');
+      expect(result.stdout).toContain('Iteration');
+      expect(result.stdout).toContain('20');
+    });
+
+    test('includes files in progress', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      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('src/feature.ts');
+      expect(result.stdout).toContain('Files In Progress');
+    });
+
+    test('includes remaining todo items', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState({
+        todo_items: ['Remaining task 1', 'Remaining task 2', 'Remaining task 3'],
+      });
+      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('Remaining task 1');
+      expect(result.stdout).toContain('Remaining Work');
+    });
+
+    test('handles missing state file gracefully', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      // Don't create state file
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout + result.stderr).toContain('not found');
+    });
+
+    test('handles minimal state gracefully', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      // Create state with minimal fields
+      stateManager.writeState(createMinimalRalphState());
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--dry-run'],
+        }
+      );
+
+      // Should not crash, even with missing checkpoint data
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Session Resume');
+    });
+  });
+
+  describe('Ralph vs Manual Mode', () => {
+    test('generates Ralph mode output by default', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      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('Ralph Autonomous');
+      expect(result.stdout).toContain('<promise>COMPLETE</promise>');
+    });
+
+    test('generates Manual mode output when specified', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--mode', 'manual', '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Manual');
+      expect(result.stdout).toContain('Manual Resume Checklist');
+      expect(result.stdout).not.toContain('<promise>COMPLETE</promise>');
+    });
+
+    test('Ralph mode includes loop guidelines', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--mode', 'ralph', '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Ralph Mode Guidelines');
+      expect(result.stdout).toContain('git checkpoints');
+    });
+
+    test('Manual mode includes resume checklist', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--mode', 'manual', '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('git status');
+      expect(result.stdout).toContain('git diff');
+    });
+  });
+
+  describe('Handoff Mode', () => {
+    test('generates prompt from handoff document', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const handoffPath = `${stateManager.baseDir}/.claude/handoffs/test-handoff.md`;
+      stateManager.writeFile('.claude/handoffs/test-handoff.md', SAMPLE_HANDOFF);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--handoff', handoffPath, '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Session Resume');
+      expect(result.stdout).toContain('Session Handoff');
+    });
+
+    test('handles missing handoff file gracefully', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--handoff', 'nonexistent.md', '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout + result.stderr).toContain('not found');
+    });
+  });
+
+  describe('Output Options', () => {
+    test('--dry-run outputs to stdout', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      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.length).toBeGreaterThan(100);
+      // Should not create PROMPT.md in dry-run mode
+      expect(existsSync(`${stateManager.baseDir}/PROMPT.md`)).toBe(false);
+    });
+
+    test('writes to PROMPT.md by default', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(`${stateManager.baseDir}/PROMPT.md`)).toBe(true);
+
+      const content = stateManager.readFile('PROMPT.md');
+      expect(content).toContain('Session Resume');
+    });
+
+    test('writes to custom output path', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      stateManager.writeState(state);
+      const customOutput = `${stateManager.baseDir}/custom-resume.md`;
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--output', customOutput],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(customOutput)).toBe(true);
+    });
+
+    test('--no-memory excludes Anvil Memory section', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      stateManager.writeState(state);
+
+      const result = await runPythonHook(
+        PROMPT_GENERATOR_PATH,
+        {},
+        {
+          cwd: stateManager.baseDir,
+          args: ['--state', stateManager.stateFile, '--no-memory', '--dry-run'],
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).not.toContain('anvil-memory');
+      expect(result.stdout).not.toContain('Memory Query');
+    });
+  });
+
+  describe('Content Validation', () => {
+    test('includes resume instructions section', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      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('Resume Instructions');
+      expect(result.stdout).toContain('CRITICAL');
+      expect(result.stdout).toContain('DO NOT restart');
+    });
+
+    test('includes next steps section', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState({
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 90,
+          timestamp: new Date().toISOString(),
+          handoff_file: '.claude/handoffs/test.md',
+          resume_summary: '',
+          files_in_progress: [],
+          current_todo_item: 'Current task',
+          progress_on_item: 'In progress',
+        },
+        todo_items: ['Next task', 'Another task'],
+      });
+      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('Next Steps');
+      expect(result.stdout).toContain('Current task');
+    });
+
+    test('includes footer with timestamp', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const state = createPromptGeneratorState();
+      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('Generated at');
+      expect(result.stdout).toContain('ralph_prompt_generator.py');
+    });
+
+    test('handoff reference includes file path', async () => {
+      if (!pythonAvailable) {
+        console.log('Skipping: Python not available');
+        return;
+      }
+
+      const handoffPath = '.claude/handoffs/session-handoff.md';
+      const state = createPromptGeneratorState({
+        context_checkpoint: {
+          active: true,
+          level: 'L2',
+          percent_at_checkpoint: 90,
+          timestamp: new Date().toISOString(),
+          handoff_file: handoffPath,
+          resume_summary: '',
+          files_in_progress: [],
+          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(handoffPath);
+      expect(result.stdout).toContain('Handoff Document');
+    });
+  });
+});
+
+describe('Prompt Generator - Script Exists', () => {
+  test('prompt generator script exists', () => {
+    expect(existsSync(PROMPT_GENERATOR_PATH)).toBe(true);
+  });
+});