fraim-framework 2.0.56 → 2.0.58

package/dist/tests/test-node-compatibility.js

@@ -1,95 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-const test_utils_1 = require("./test-utils");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-async function testInitOnNodeVersion(version) {
-    console.log(`   🧪 Testing Node v${version}...`);
-    // Create a temp directory for each version test
-    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `fraim-node-${version}-`));
-    try {
-        // Set up git repository (required for new init logic)
-        const { execSync } = require('child_process');
-        execSync('git init', { cwd: tempDir });
-        execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir });
-        const platform = process.platform;
-        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
-        const binPath = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
-        // Run: npx -y -p node@<version> node bin/fraim.js init
-        // We use -y to skip prompt, and -p node@version to ensure that specific node binary is used
-        const execNode = (args) => {
-            return new Promise((resolve) => {
-                const ps = (0, node_child_process_1.spawn)(npx, ['-y', '-p', `node@${version}`, 'node', `"${binPath}"`, ...args], {
-                    cwd: tempDir,
-                    env: { ...process.env, TEST_MODE: 'true' },
-                    shell: true
-                });
-                let stdout = '';
-                let stderr = '';
-                let timedOut = false;
-                // Set a timeout of 30 seconds for npx to download and run
-                const timeout = setTimeout(() => {
-                    timedOut = true;
-                    ps.kill();
-                }, 30000);
-                ps.stdout.on('data', d => stdout += d.toString());
-                ps.stderr.on('data', d => stderr += d.toString());
-                ps.on('close', (code) => {
-                    clearTimeout(timeout);
-                    resolve({ stdout, stderr, code, timedOut });
-                });
-            });
-        };
-        console.log(`      Running "fraim init" on Node ${version}...`);
-        const result = await execNode(['init']);
-        if (result.timedOut) {
-            console.log(`      ⚠️  Skipped Node ${version} (timeout - version may not be available)`);
-            return true; // Don't fail the test, just skip it
-        }
-        if (result.code !== 0) {
-            // Check if it's a version availability issue
-            if (result.stderr.includes('ETARGET') || result.stderr.includes('No matching version')) {
-                console.log(`      ⚠️  Skipped Node ${version} (version not available)`);
-                return true; // Don't fail the test
-            }
-            console.error(`      ❌ Failed on Node ${version}`);
-            console.error(`      Error: ${result.stderr}`);
-            return false;
-        }
-        const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
-        if (fs_1.default.existsSync(configPath)) {
-            console.log(`      ✅ Success on Node ${version}`);
-            return true;
-        }
-        else {
-            console.error(`      ❌ Config not found on Node ${version}`);
-            return false;
-        }
-    }
-    catch (e) {
-        console.error(`      ❌ Test Logic Error on Node ${version}:`, e.message);
-        return false;
-    }
-    finally {
-        try {
-            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch (e) { }
-    }
-}
-const nodeVersions = ['16', '18', '20', '22'];
-const testCases = nodeVersions.map(v => ({
-    name: `Node v${v} Compatibility`,
-    version: v,
-    tags: ['node', 'compatibility']
-}));
-(0, test_utils_1.runTests)(testCases, async (t) => await testInitOnNodeVersion(t.version), 'Node Compatibility Matrix')
-    .catch((err) => {
-    console.error('Test runner failed:', err);
-    throw err;
-});

package/dist/tests/test-npm-install.js

@@ -1,68 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-const test_utils_1 = require("./test-utils");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-async function testCleanNpmInstall(version) {
-    console.log(`   🧪 Testing NPM Install on Node v${version}...`);
-    // Create a temp directory for the install test
-    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `fraim-npm-${version}-`));
-    try {
-        const platform = process.platform;
-        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
-        // Copy package.json to temp dir
-        const packageJsonPath = path_1.default.resolve(__dirname, '../package.json');
-        fs_1.default.copyFileSync(packageJsonPath, path_1.default.join(tempDir, 'package.json'));
-        // Run: npx -p node@<version> npm install --package-lock-only
-        // This uses the npm bundled with that specific Node version
-        const execNpm = () => {
-            return new Promise((resolve) => {
-                const ps = (0, node_child_process_1.spawn)(npx, ['-y', '-p', `node@${version}`, 'npm', 'install', '--package-lock-only', '--quiet', '--no-audit'], {
-                    cwd: tempDir,
-                    env: { ...process.env },
-                    shell: true
-                });
-                let stdout = '';
-                let stderr = '';
-                ps.stdout.on('data', d => stdout += d.toString());
-                ps.stderr.on('data', d => stderr += d.toString());
-                ps.on('close', (code) => resolve({ stdout, stderr, code }));
-            });
-        };
-        console.log(`      Running "npm install" with Node ${version}...`);
-        const result = await execNpm();
-        if (result.code !== 0) {
-            console.error(`      ❌ NPM Install Failed on Node ${version}`);
-            console.error(`      Stderr: ${result.stderr}`);
-            return false;
-        }
-        console.log(`      ✅ NPM Resolution Success on Node ${version}`);
-        return true;
-    }
-    catch (e) {
-        console.error(`      ❌ Test Logic Error on Node ${version}:`, e.message);
-        return false;
-    }
-    finally {
-        try {
-            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch (e) { }
-    }
-}
-const nodeVersions = ['16', '18', '20', '22'];
-const testCases = nodeVersions.map(v => ({
-    name: `NPM Compatibility (Node v${v})`,
-    version: v,
-    tags: ['npm', 'compatibility']
-}));
-(0, test_utils_1.runTests)(testCases, async (t) => await testCleanNpmInstall(t.version), 'NPM Configuration Matrix')
-    .catch((err) => {
-    console.error('Test runner failed:', err);
-    throw err;
-});

package/dist/tests/test-package-size.js

@@ -1,108 +0,0 @@
-#!/usr/bin/env tsx
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_test_1 = require("node:test");
-const node_assert_1 = __importDefault(require("node:assert"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-/**
- * Test to verify package size reduction from stub-only registry
- */
-// Find project root by looking for package.json
-function findProjectRoot() {
-    let currentDir = __dirname;
-    while (currentDir !== path_1.default.dirname(currentDir)) {
-        if (fs_1.default.existsSync(path_1.default.join(currentDir, 'package.json'))) {
-            return currentDir;
-        }
-        currentDir = path_1.default.dirname(currentDir);
-    }
-    throw new Error('Could not find project root (package.json not found)');
-}
-(0, node_test_1.test)('Stub registry is significantly smaller than full registry', () => {
-    const projectRoot = findProjectRoot();
-    const fullWorkflowsPath = path_1.default.join(projectRoot, 'registry', 'workflows');
-    const stubWorkflowsPath = path_1.default.join(projectRoot, 'registry', 'stubs', 'workflows');
-    console.log(`Project root: ${projectRoot}`);
-    console.log(`Full workflows path: ${fullWorkflowsPath}`);
-    console.log(`Stub workflows path: ${stubWorkflowsPath}`);
-    (0, node_assert_1.default)(fs_1.default.existsSync(fullWorkflowsPath), 'Full workflows directory should exist');
-    (0, node_assert_1.default)(fs_1.default.existsSync(stubWorkflowsPath), 'Stub workflows directory should exist');
-    // Calculate sizes
-    const fullSize = getDirectorySize(fullWorkflowsPath);
-    const stubSize = getDirectorySize(stubWorkflowsPath);
-    console.log(`Full workflows size: ${fullSize} bytes`);
-    console.log(`Stub workflows size: ${stubSize} bytes`);
-    console.log(`Size reduction: ${Math.round((1 - stubSize / fullSize) * 100)}%`);
-    // Stubs should be significantly smaller
-    (0, node_assert_1.default)(stubSize < fullSize * 0.3, `Stubs should be <30% of full size (actual: ${Math.round(stubSize / fullSize * 100)}%)`);
-    // Should have same number of files
-    const fullFiles = getAllFiles(fullWorkflowsPath, '.md');
-    const stubFiles = getAllFiles(stubWorkflowsPath, '.md');
-    console.log(`Full files found: ${fullFiles.length}`);
-    console.log(`Stub files found: ${stubFiles.length}`);
-    console.log(`First few full files: ${fullFiles.slice(0, 3).join(', ')}`);
-    console.log(`First few stub files: ${stubFiles.slice(0, 3).join(', ')}`);
-    node_assert_1.default.strictEqual(stubFiles.length, fullFiles.length, 'Should have same number of workflow files');
-    console.log(`✅ Package size reduced by ${Math.round((1 - stubSize / fullSize) * 100)}% while maintaining all ${stubFiles.length} workflows`);
-});
-(0, node_test_1.test)('Package excludes full workflows and templates', () => {
-    const projectRoot = findProjectRoot();
-    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
-    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
-    const files = packageJson.files || [];
-    // Calculate what would be excluded
-    const fullWorkflowsSize = getDirectorySize(path_1.default.join(projectRoot, 'registry', 'workflows'));
-    const templatesSize = getDirectorySize(path_1.default.join(projectRoot, 'registry', 'templates'));
-    const rulesSize = getDirectorySize(path_1.default.join(projectRoot, 'registry', 'rules'));
-    const excludedSize = fullWorkflowsSize + templatesSize + rulesSize;
-    // What's included
-    const stubsSize = getDirectorySize(path_1.default.join(projectRoot, 'registry', 'stubs'));
-    const scriptsSize = getDirectorySize(path_1.default.join(projectRoot, 'registry', 'scripts'));
-    const includedSize = stubsSize + scriptsSize;
-    console.log(`Excluded from package: ${excludedSize} bytes (workflows + templates + rules)`);
-    console.log(`Included in package: ${includedSize} bytes (stubs + scripts)`);
-    console.log(`Total registry size reduction: ${Math.round((1 - includedSize / (includedSize + excludedSize)) * 100)}%`);
-    // Verify significant size reduction
-    (0, node_assert_1.default)(includedSize < excludedSize, 'Package should exclude more content than it includes');
-    console.log('✅ Package correctly excludes heavy content while keeping essentials');
-});
-function getDirectorySize(dirPath) {
-    if (!fs_1.default.existsSync(dirPath)) {
-        return 0;
-    }
-    let totalSize = 0;
-    const files = getAllFiles(dirPath);
-    for (const file of files) {
-        try {
-            const stats = fs_1.default.statSync(file);
-            totalSize += stats.size;
-        }
-        catch (e) {
-            // Skip files that can't be read
-        }
-    }
-    return totalSize;
-}
-function getAllFiles(dir, extension) {
-    const files = [];
-    if (!fs_1.default.existsSync(dir)) {
-        return files;
-    }
-    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path_1.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...getAllFiles(fullPath, extension));
-        }
-        else if (entry.isFile()) {
-            if (!extension || entry.name.endsWith(extension)) {
-                files.push(fullPath);
-            }
-        }
-    }
-    return files;
-}

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

@@ -1,307 +0,0 @@
-"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, 'retrospective', 'After wait-for-pr-review should go to retrospective');
-        const nextAfterRetrospective = (0, phase_flow_js_1.getNextPhase)('retrospective', 'implement', 'bug');
-        node_assert_1.strict.equal(nextAfterRetrospective, null, 'retrospective 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 (should go to address-pr-feedback)
-        const waitPRFailure = (0, phase_flow_js_1.getPhaseOnFailure)('wait-for-pr-review', 'implement', 'bug');
-        node_assert_1.strict.equal(waitPRFailure, 'address-pr-feedback', 'wait-for-pr-review failure should go to address-pr-feedback');
-        // 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 nextPhaseAfterPR = (0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', workflowType, issueType);
-        node_assert_1.strict.equal(nextPhaseAfterPR, 'retrospective', 'wait-for-pr-review should go to retrospective when approved');
-        const finalPhase = (0, phase_flow_js_1.getNextPhase)('retrospective', workflowType, issueType);
-        node_assert_1.strict.equal(finalPhase, null, 'retrospective 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, 'address-pr-feedback', 'PR changes requested should route to address-pr-feedback');
-        // Test iteration: after addressing feedback, go through validation again
-        let iterationPhase = 'address-pr-feedback';
-        // After addressing feedback, should go to validation phase
-        const nextAfterFeedback = (0, phase_flow_js_1.getNextPhase)(iterationPhase, workflowType, issueType);
-        node_assert_1.strict.equal(nextAfterFeedback, 'implement-validate', 'After address-pr-feedback should go to implement-validate');
-        iterationPhase = nextAfterFeedback;
-        const iterationFlow = ['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');