fraim-framework 2.0.44 → 2.0.45

package/dist/tests/test-pr-review-workflow.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const test_utils_1 = require("./test-utils");
+const phase_flow_js_1 = require("../src/ai-manager/phase-flow.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Test PR Review Workflow Phase Flow
+ */
+async function testPRReviewPhaseFlow() {
+    try {
+        console.log('🧪 Testing PR review phase flow...');
+        // Test bug workflow includes new phases
+        const bugPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('implement', 'bug');
+        (0, node_assert_1.strict)(bugPhases.includes('submit-pr'), 'Bug workflow should include submit-pr phase');
+        (0, node_assert_1.strict)(bugPhases.includes('wait-for-pr-review'), 'Bug workflow should include wait-for-pr-review phase');
+        // Test feature workflow includes new phases
+        const featurePhases = (0, phase_flow_js_1.getPhasesForWorkflow)('implement', 'feature');
+        (0, node_assert_1.strict)(featurePhases.includes('submit-pr'), 'Feature workflow should include submit-pr phase');
+        (0, node_assert_1.strict)(featurePhases.includes('wait-for-pr-review'), 'Feature workflow should include wait-for-pr-review phase');
+        // Test phase progression
+        const nextAfterCompleteness = (0, phase_flow_js_1.getNextPhase)('implement-completeness-review', 'implement', 'bug');
+        node_assert_1.strict.equal(nextAfterCompleteness, 'submit-pr', 'After completeness-review should go to submit-pr');
+        const nextAfterSubmitPR = (0, phase_flow_js_1.getNextPhase)('submit-pr', 'implement', 'bug');
+        node_assert_1.strict.equal(nextAfterSubmitPR, 'wait-for-pr-review', 'After submit-pr should go to wait-for-pr-review');
+        const nextAfterWaitPR = (0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', 'implement', 'bug');
+        node_assert_1.strict.equal(nextAfterWaitPR, null, 'wait-for-pr-review should be the last phase');
+        console.log('✅ PR review phase flow tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ PR review phase flow test failed:', error.message);
+        return false;
+    }
+}
+/**
+ * Test PR Review Failure Handling
+ */
+async function testPRReviewFailureHandling() {
+    try {
+        console.log('🧪 Testing PR review failure handling...');
+        // Test submit-pr failure
+        const submitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('submit-pr', 'implement', 'bug');
+        node_assert_1.strict.equal(submitPRFailure, 'implement-completeness-review', 'submit-pr failure should return to completeness-review');
+        // Test wait-for-pr-review failure (default)
+        const waitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', 'implement', 'bug');
+        node_assert_1.strict.equal(waitPRFailure, 'implement-code', 'wait-for-pr-review failure should default to implement-code');
+        // Test all workflow types have new phases
+        const specPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('spec');
+        (0, node_assert_1.strict)(specPhases.includes('submit-pr'), 'Spec workflow should include submit-pr');
+        (0, node_assert_1.strict)(specPhases.includes('wait-for-pr-review'), 'Spec workflow should include wait-for-pr-review');
+        const designPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('design');
+        (0, node_assert_1.strict)(designPhases.includes('submit-pr'), 'Design workflow should include submit-pr');
+        (0, node_assert_1.strict)(designPhases.includes('wait-for-pr-review'), 'Design workflow should include wait-for-pr-review');
+        console.log('✅ PR review failure handling tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ PR review failure handling test failed:', error.message);
+        return false;
+    }
+}
+/**
+ * Test PR Comment Polling Script (Mock)
+ */
+async function testPRCommentPollingScript() {
+    try {
+        console.log('🧪 Testing PR comment polling script...');
+        // Create mock .fraim/config.json
+        const testDir = (0, path_1.join)(process.cwd(), 'test_temp');
+        const fraimDir = (0, path_1.join)(testDir, '.fraim');
+        if ((0, fs_1.existsSync)(testDir)) {
+            (0, fs_1.rmSync)(testDir, { recursive: true, force: true });
+        }
+        (0, fs_1.mkdirSync)(fraimDir, { recursive: true });
+        const mockConfig = {
+            git: {
+                repoOwner: 'test-owner',
+                repoName: 'test-repo'
+            }
+        };
+        (0, fs_1.writeFileSync)((0, path_1.join)(fraimDir, 'config.json'), JSON.stringify(mockConfig, null, 2));
+        // Test script exists and is executable
+        const scriptPath = (0, path_1.join)(process.cwd(), 'scripts', 'sleep-and-continue.js');
+        (0, node_assert_1.strict)((0, fs_1.existsSync)(scriptPath), 'Sleep utility script should exist');
+        // Test script can be executed (syntax check)
+        const { execSync } = require('child_process');
+        try {
+            // Test help output
+            execSync('node scripts/sleep-and-continue.js --help', { stdio: 'pipe' });
+        }
+        catch (error) {
+            // Expected to fail with usage message, which is fine
+            (0, node_assert_1.strict)(error.message.includes('Usage:'), 'Script should show usage when called incorrectly');
+        }
+        // Cleanup
+        (0, fs_1.rmSync)(testDir, { recursive: true, force: true });
+        console.log('✅ PR comment polling script tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ PR comment polling script test failed:', error.message);
+        return false;
+    }
+}
+/**
+ * Test PR Feedback File System
+ */
+async function testPRCommentVerificationScript() {
+    try {
+        console.log('🧪 Testing PR feedback file system...');
+        const testDir = (0, path_1.join)(process.cwd(), 'test_temp');
+        const evidenceDir = (0, path_1.join)(testDir, 'evidence');
+        if ((0, fs_1.existsSync)(testDir)) {
+            (0, fs_1.rmSync)(testDir, { recursive: true, force: true });
+        }
+        (0, fs_1.mkdirSync)(evidenceDir, { recursive: true });
+        // Create mock feedback document using new format
+        const mockFeedbackDoc = `# PR Feedback for Issue #123 - Implement Workflow
+
+## Round 1 Feedback
+*Received: 2024-01-15T10:30:00Z*
+
+### Comment 1 - ADDRESSED
+- **Author**: reviewer1
+- **Type**: review_comment
+- **File**: src/test.ts
+- **Line**: 45
+- **Comment**: This function needs error handling
+- **Status**: ADDRESSED
+- **Resolution**: Added try-catch block and proper error handling
+
+### Comment 2 - ADDRESSED
+- **Author**: reviewer2
+- **Type**: pr_comment
+- **Comment**: Please add unit tests for this feature
+- **Status**: ADDRESSED
+- **Resolution**: Added comprehensive unit tests in test/feature.test.ts
+`;
+        const feedbackDocPath = (0, path_1.join)(evidenceDir, '123-implement-feedback.md');
+        (0, fs_1.writeFileSync)(feedbackDocPath, mockFeedbackDoc);
+        // Test that feedback document was created and has expected content
+        (0, node_assert_1.strict)((0, fs_1.existsSync)(feedbackDocPath), 'PR feedback document should exist');
+        const content = (0, fs_1.readFileSync)(feedbackDocPath, 'utf-8');
+        (0, node_assert_1.strict)(content.includes('## Round 1 Feedback'), 'Document should contain Round 1 Feedback');
+        (0, node_assert_1.strict)(content.includes('### Comment 1 - ADDRESSED'), 'Document should contain Comment 1 with status');
+        (0, node_assert_1.strict)(content.includes('### Comment 2 - ADDRESSED'), 'Document should contain Comment 2 with status');
+        (0, node_assert_1.strict)(content.includes('reviewer1'), 'Document should contain reviewer1');
+        (0, node_assert_1.strict)(content.includes('reviewer2'), 'Document should contain reviewer2');
+        (0, node_assert_1.strict)(content.includes('Status**: ADDRESSED'), 'Comments should be marked as ADDRESSED');
+        // Cleanup
+        (0, fs_1.rmSync)(testDir, { recursive: true, force: true });
+        console.log('✅ PR feedback file system tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ PR feedback file system test failed:', error.message);
+        return false;
+    }
+}
+/**
+ * Test Real-World PR Review Scenario
+ */
+async function testRealWorldPRReviewScenario() {
+    try {
+        console.log('🧪 Testing real-world PR review scenario...');
+        // Scenario: Feature implementation with PR feedback
+        let currentPhase = 'implement-scoping';
+        const workflowType = 'implement';
+        const issueType = 'feature';
+        // Progress through normal phases
+        const expectedFlow = [
+            'implement-scoping',
+            'implement-spike',
+            'implement-code',
+            'implement-validate',
+            'implement-smoke',
+            'implement-regression',
+            'implement-completeness-review',
+            'submit-pr',
+            'wait-for-pr-review'
+        ];
+        for (let i = 0; i < expectedFlow.length - 1; i++) {
+            const nextPhase = (0, phase_flow_js_1.getNextPhase)(currentPhase, workflowType, issueType);
+            node_assert_1.strict.equal(nextPhase, expectedFlow[i + 1], `After ${currentPhase} should go to ${expectedFlow[i + 1]}`);
+            currentPhase = nextPhase;
+        }
+        // Test PR review completion (approved)
+        const finalPhase = (0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', workflowType, issueType);
+        node_assert_1.strict.equal(finalPhase, null, 'wait-for-pr-review should be final phase when approved');
+        // Test PR review with changes requested (failure scenario)
+        const failurePhase = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', workflowType, issueType);
+        node_assert_1.strict.equal(failurePhase, 'implement-code', 'PR changes requested should route to implement-code by default');
+        // Test iteration: after fixing code, go through validation again
+        let iterationPhase = 'implement-code';
+        const iterationFlow = ['implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
+        for (const expectedNext of iterationFlow) {
+            const nextPhase = (0, phase_flow_js_1.getNextPhase)(iterationPhase, workflowType, issueType);
+            node_assert_1.strict.equal(nextPhase, expectedNext, `Iteration: after ${iterationPhase} should go to ${expectedNext}`);
+            iterationPhase = nextPhase;
+        }
+        console.log('✅ Real-world PR review scenario tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Real-world PR review scenario test failed:', error.message);
+        return false;
+    }
+}
+/**
+ * Test PR Comment Routing Logic
+ */
+async function testPRCommentRoutingLogic() {
+    try {
+        console.log('🧪 Testing PR comment routing logic...');
+        // Test different comment types should route to different phases
+        // This would be implemented in the wait-for-pr-review phase logic
+        // Mock comment analysis scenarios
+        const commentScenarios = [
+            {
+                comment: "This doesn't match the requirements in the spec",
+                expectedRoute: 'implement-scoping', // or spec-spec for spec workflow
+                category: 'requirements'
+            },
+            {
+                comment: "The API design doesn't follow our patterns",
+                expectedRoute: 'design-design',
+                category: 'design'
+            },
+            {
+                comment: "This code has a memory leak",
+                expectedRoute: 'implement-code',
+                category: 'code_quality'
+            },
+            {
+                comment: "Missing test coverage for edge cases",
+                expectedRoute: 'implement-validate',
+                category: 'testing'
+            },
+            {
+                comment: "The documentation is incomplete",
+                expectedRoute: 'implement-completeness-review',
+                category: 'documentation'
+            }
+        ];
+        // For now, just verify the routing logic exists in the failure handling
+        for (const scenario of commentScenarios) {
+            // The actual routing would be implemented in the wait-for-pr-review phase
+            // For now, we test that the failure handling provides reasonable defaults
+            const routePhase = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', 'implement', 'feature');
+            (0, node_assert_1.strict)(typeof routePhase === 'string', `Should return a valid phase for routing`);
+        }
+        console.log('✅ PR comment routing logic tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ PR comment routing logic test failed:', error.message);
+        return false;
+    }
+}
+/**
+ * Test Phase Validation
+ */
+async function testPhaseValidation() {
+    try {
+        console.log('🧪 Testing phase validation...');
+        // Test new phases are valid for all workflow types
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'implement', 'bug'), 'submit-pr should be valid for implement workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'implement', 'bug'), 'wait-for-pr-review should be valid for implement workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'spec'), 'submit-pr should be valid for spec workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'spec'), 'wait-for-pr-review should be valid for spec workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'design'), 'submit-pr should be valid for design workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'design'), 'wait-for-pr-review should be valid for design workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'test'), 'submit-pr should be valid for test workflow');
+        (0, node_assert_1.strict)((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'test'), 'wait-for-pr-review should be valid for test workflow');
+        // Test old finalize phase is no longer valid
+        (0, node_assert_1.strict)(!(0, phase_flow_js_1.isPhaseValidForWorkflow)('finalize', 'implement', 'bug'), 'finalize should no longer be valid for implement workflow');
+        (0, node_assert_1.strict)(!(0, phase_flow_js_1.isPhaseValidForWorkflow)('finalize', 'spec'), 'finalize should no longer be valid for spec workflow');
+        console.log('✅ Phase validation tests passed');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Phase validation test failed:', error.message);
+        return false;
+    }
+}
+// Test cases
+const testCases = [
+    { name: 'PR Review Phase Flow', testFn: testPRReviewPhaseFlow },
+    { name: 'PR Review Failure Handling', testFn: testPRReviewFailureHandling },
+    { name: 'PR Comment Polling Script', testFn: testPRCommentPollingScript },
+    { name: 'PR Feedback File System', testFn: testPRCommentVerificationScript },
+    { name: 'Real-World PR Review Scenario', testFn: testRealWorldPRReviewScenario },
+    { name: 'PR Comment Routing Logic', testFn: testPRCommentRoutingLogic },
+    { name: 'Phase Validation', testFn: testPhaseValidation }
+];
+// Run tests
+(0, test_utils_1.runTests)(testCases, async (t) => t.testFn(), 'PR Review Workflow Tests');

package/dist/website/404.html

@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Page Not Found - FRAIM</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', sans-serif;
+            background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: #1a1a1a;
+        }
+
+        .error-container {
+            text-align: center;
+            max-width: 600px;
+            padding: 40px 20px;
+        }
+
+        .error-code {
+            font-size: 120px;
+            font-weight: 700;
+            background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 50%, #ec4899 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            margin-bottom: 20px;
+        }
+
+        .error-title {
+            font-size: 32px;
+            font-weight: 600;
+            margin-bottom: 16px;
+        }
+
+        .error-message {
+            font-size: 18px;
+            color: #666;
+            margin-bottom: 32px;
+            line-height: 1.5;
+        }
+
+        .home-button {
+            background: #6366f1;
+            color: white;
+            padding: 12px 24px;
+            border-radius: 8px;
+            text-decoration: none;
+            font-weight: 600;
+            transition: all 0.2s;
+            display: inline-block;
+        }
+
+        .home-button:hover {
+            background: #5855eb;
+            transform: translateY(-1px);
+        }
+
+        .logo {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+            margin-bottom: 40px;
+            font-size: 24px;
+            font-weight: 700;
+        }
+
+        .logo-icon {
+            font-size: 32px;
+        }
+    </style>
+</head>
+<body>
+    <div class="error-container">
+        <div class="logo">
+            <span class="logo-icon">🚀</span>
+            <span>FRAIM</span>
+        </div>
+        <div class="error-code">404</div>
+        <h1 class="error-title">Page Not Found</h1>
+        <p class="error-message">
+            The page you're looking for doesn't exist. It might have been moved, deleted, or you entered the wrong URL.
+        </p>
+        <a href="/" class="home-button">Back to Home</a>
+    </div>
+</body>
+</html>

package/dist/website/CNAME

@@ -0,0 +1 @@
+fraimworks.ai

package/dist/website/README.md

@@ -0,0 +1,22 @@
+# FRAIM Website
+
+This directory contains the FRAIM marketing website with dark/light mode toggle.
+
+## Features
+- Responsive design with mobile support
+- Dark/light mode toggle with system preference detection
+- Professional branding and animations
+- GitHub Pages deployment via GitHub Actions
+
+## Deployment
+The site is automatically deployed to GitHub Pages via GitHub Actions when changes are pushed to the `website/` folder.
+
+**Site URL**: https://mathursrus.github.io/FRAIM/
+
+## Files
+- `index.html` - Main landing page
+- `demo.html` - Interactive demo page
+- `styles.css` - CSS with dark/light mode variables
+- `script.js` - JavaScript for theme toggle and animations
+- `404.html` - Custom error page
+- `.nojekyll` - Prevents Jekyll processing