fraim-framework 2.0.56 → 2.0.58

package/dist/tests/test-end-to-end-hybrid-validation.js

@@ -1,328 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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 node_assert_1 = __importDefault(require("node:assert"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-async function testCompleteHybridWorkflow() {
-    console.log('   🚀 Testing Complete Hybrid Workflow...');
-    const tempProjectDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-e2e-hybrid-'));
-    const userFraimDir = path_1.default.join(os_1.default.homedir(), '.fraim-e2e-test');
-    try {
-        // Clean up any existing test user directory
-        if (fs_1.default.existsSync(userFraimDir)) {
-            fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
-        }
-        console.log(`   📂 Project dir: ${tempProjectDir}`);
-        console.log(`   🏠 User dir: ${userFraimDir}`);
-        // Set up git repository
-        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-        execSync('git init', { cwd: tempProjectDir });
-        execSync('git remote add origin https://github.com/test-owner/e2e-hybrid-test.git', { cwd: tempProjectDir });
-        // Run fraim init with custom user directory
-        const platform = process.platform;
-        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
-        const cliScript = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
-        const runFraim = (args) => {
-            return new Promise((resolve) => {
-                const ps = (0, node_child_process_1.spawn)(npx, ['node', `"${cliScript}"`, ...args], {
-                    cwd: tempProjectDir,
-                    env: {
-                        ...process.env,
-                        TEST_MODE: 'true',
-                        FRAIM_USER_DIR: userFraimDir
-                    },
-                    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 });
-                });
-            });
-        };
-        // Initialize FRAIM
-        console.log('   Initializing FRAIM...');
-        const initRes = await runFraim(['init']);
-        node_assert_1.default.strictEqual(initRes.code, 0, 'Init should succeed');
-        // Verify user scripts directory was created and populated
-        const userScriptsDir = path_1.default.join(userFraimDir, 'scripts');
-        node_assert_1.default.ok(fs_1.default.existsSync(userScriptsDir), 'User scripts directory should exist');
-        // Verify self-contained scripts were synced
-        const expectedSelfContainedScripts = [
-            'prep-issue.sh',
-            'code-quality-check.sh',
-            'exec-with-timeout.ts',
-            'evaluate-code-quality.ts'
-        ];
-        for (const scriptName of expectedSelfContainedScripts) {
-            const scriptPath = path_1.default.join(userScriptsDir, scriptName);
-            node_assert_1.default.ok(fs_1.default.existsSync(scriptPath), `Self-contained script ${scriptName} should be synced`);
-        }
-        // Verify dependent scripts were NOT synced
-        const expectedDependentScripts = [
-            'fraim-config.ts',
-            'build-scripts-generator.ts'
-        ];
-        for (const scriptName of expectedDependentScripts) {
-            const scriptPath = path_1.default.join(userScriptsDir, scriptName);
-            node_assert_1.default.ok(!fs_1.default.existsSync(scriptPath), `Dependent script ${scriptName} should NOT be synced`);
-        }
-        // Test that self-contained scripts can execute from user directory
-        console.log('   Testing self-contained script execution...');
-        // Create a simple test script to verify execution context
-        const testScript = `#!/usr/bin/env node
-console.log('WORKING_DIR=' + process.cwd());
-console.log('SCRIPT_DIR=' + __dirname);
-
-// Verify we can read project config
-const fs = require('fs');
-const path = require('path');
-
-try {
-    const configPath = path.join(process.cwd(), '.fraim', 'config.json');
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    console.log('PROJECT_NAME=' + config.project.name);
-    console.log('SUCCESS=true');
-} catch (error) {
-    console.log('ERROR=' + error.message);
-    console.log('SUCCESS=false');
-}
-`;
-        const testScriptPath = path_1.default.join(userScriptsDir, 'test-execution.js');
-        fs_1.default.writeFileSync(testScriptPath, testScript);
-        // Execute the test script from project directory
-        let output;
-        try {
-            output = execSync(`node "${testScriptPath}"`, {
-                cwd: tempProjectDir,
-                encoding: 'utf-8'
-            });
-        }
-        catch (error) {
-            throw new Error(`Script execution failed: ${error.message}`);
-        }
-        // Validate execution results
-        node_assert_1.default.ok(output.includes('SUCCESS=true'), 'Script should execute successfully');
-        node_assert_1.default.ok(output.includes('PROJECT_NAME=e2e-hybrid-test'), 'Should read project config correctly');
-        // Verify working directory vs script directory are different
-        const workingDirMatch = output.match(/WORKING_DIR=(.+)/);
-        const scriptDirMatch = output.match(/SCRIPT_DIR=(.+)/);
-        if (workingDirMatch && scriptDirMatch) {
-            const workingDir = workingDirMatch[1].trim();
-            const scriptDir = scriptDirMatch[1].trim();
-            node_assert_1.default.notStrictEqual(workingDir, scriptDir, 'Working directory should be different from script directory');
-        }
-        // Test sync command updates
-        console.log('   Testing sync command...');
-        const syncRes = await runFraim(['sync']);
-        // Sync might warn but should not fail completely
-        if (syncRes.code !== 0) {
-            console.log('   ⚠️ Sync returned non-zero (environment dependent)');
-        }
-        // Verify scripts are still present after sync
-        for (const scriptName of expectedSelfContainedScripts) {
-            const scriptPath = path_1.default.join(userScriptsDir, scriptName);
-            node_assert_1.default.ok(fs_1.default.existsSync(scriptPath), `Script ${scriptName} should still exist after sync`);
-        }
-        console.log('   ✅ Complete hybrid workflow verified!');
-        return true;
-    }
-    catch (error) {
-        console.error('   ❌ End-to-end hybrid test failed:', error);
-        return false;
-    }
-    finally {
-        try {
-            fs_1.default.rmSync(tempProjectDir, { recursive: true, force: true });
-            if (fs_1.default.existsSync(userFraimDir)) {
-                fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
-            }
-        }
-        catch (e) { }
-    }
-}
-async function testScriptCategorizationAccuracy() {
-    console.log('   🚀 Testing Script Categorization Accuracy...');
-    try {
-        const registryPath = path_1.default.resolve(__dirname, '../registry');
-        if (!fs_1.default.existsSync(registryPath)) {
-            console.log('   ⚠️ Registry not found, skipping script sync test');
-            return true;
-        }
-        const { getRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
-        const allScripts = getRegistryScripts(registryPath);
-        console.log(`   📊 Script sync results:`);
-        console.log(`     Total scripts: ${allScripts.length} scripts`);
-        // Verify some known scripts exist
-        const knownScripts = [
-            'prep-issue.sh',
-            'code-quality-check.sh',
-            'exec-with-timeout.ts',
-            'evaluate-code-quality.ts',
-            'comprehensive-explorer.py',
-            'interactive-explorer.py',
-            'scrape-site.py'
-        ];
-        const scriptNames = allScripts.map(p => path_1.default.basename(p));
-        for (const scriptName of knownScripts) {
-            const scriptPath = path_1.default.join(registryPath, 'scripts', scriptName);
-            if (fs_1.default.existsSync(scriptPath)) {
-                node_assert_1.default.ok(scriptNames.includes(scriptName), `${scriptName} should be included in sync`);
-            }
-        }
-        console.log('   ✅ All known scripts are included');
-        return true;
-    }
-    catch (error) {
-        console.error('   ❌ Script categorization accuracy test failed:', error);
-        return false;
-    }
-}
-async function testWorkflowInstructionConsistency() {
-    console.log('   🚀 Testing Workflow Instruction Consistency...');
-    try {
-        const registryPath = path_1.default.resolve(__dirname, '../registry');
-        if (!fs_1.default.existsSync(registryPath)) {
-            console.log('   ⚠️ Registry not found, skipping workflow consistency test');
-            return true;
-        }
-        // Check that workflows use the correct execution patterns
-        const workflowsPath = path_1.default.join(registryPath, 'workflows');
-        const rulesPath = path_1.default.join(registryPath, 'rules');
-        // Get all markdown files
-        const getMarkdownFiles = (dir) => {
-            if (!fs_1.default.existsSync(dir))
-                return [];
-            const 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(...getMarkdownFiles(fullPath));
-                }
-                else if (entry.name.endsWith('.md')) {
-                    files.push(fullPath);
-                }
-            }
-            return files;
-        };
-        const allMarkdownFiles = [
-            ...getMarkdownFiles(workflowsPath),
-            ...getMarkdownFiles(rulesPath)
-        ];
-        let inconsistencies = 0;
-        for (const filePath of allMarkdownFiles) {
-            const content = fs_1.default.readFileSync(filePath, 'utf-8');
-            const relativePath = path_1.default.relative(registryPath, filePath);
-            // Check for old ephemeral execution patterns (but allow them for dependent scripts)
-            const oldPatterns = [
-                /tmp\/.*\.ts/g,
-                /tmp\/.*\.sh/g
-            ];
-            for (const pattern of oldPatterns) {
-                const matches = content.match(pattern);
-                if (matches) {
-                    // Allow tmp/ usage if it's accompanied by get_fraim_file (ephemeral execution for dependent scripts)
-                    const hasGetFramFile = /get_fraim_file.*scripts/.test(content);
-                    if (!hasGetFramFile) {
-                        console.log(`   ⚠️ Found old pattern in ${relativePath}: ${matches.join(', ')}`);
-                        inconsistencies++;
-                    }
-                }
-            }
-            // Check for correct hybrid patterns
-            const hybridPatterns = [
-                /~\/\.fraim\/scripts\/.*\.ts/g,
-                /~\/\.fraim\/scripts\/.*\.sh/g,
-                /%USERPROFILE%\\\.fraim\\scripts\\/g
-            ];
-            let hasHybridPatterns = false;
-            for (const pattern of hybridPatterns) {
-                if (pattern.test(content)) {
-                    hasHybridPatterns = true;
-                    break;
-                }
-            }
-            // If file mentions scripts but doesn't use hybrid patterns, it might be an issue
-            if (content.includes('scripts/') && !hasHybridPatterns && inconsistencies === 0) {
-                // This is just informational, not necessarily an error
-                console.log(`   ℹ️ File ${relativePath} mentions scripts but may not use hybrid patterns`);
-            }
-        }
-        if (inconsistencies > 0) {
-            console.log(`   ❌ Found ${inconsistencies} workflow instruction inconsistencies`);
-            return false;
-        }
-        console.log('   ✅ Workflow instruction consistency verified!');
-        return true;
-    }
-    catch (error) {
-        console.error('   ❌ Workflow instruction consistency test failed:', error);
-        return false;
-    }
-}
-async function runEndToEndTest(testCase) {
-    return await testCase.testFunction();
-}
-const testCases = [
-    {
-        name: 'Complete Hybrid Workflow',
-        description: 'Tests the entire hybrid script execution workflow from init to execution',
-        testFunction: testCompleteHybridWorkflow,
-        tags: ['e2e', 'hybrid', 'workflow']
-    },
-    {
-        name: 'Script Categorization Accuracy',
-        description: 'Validates that all scripts are correctly categorized as self-contained or dependent',
-        testFunction: testScriptCategorizationAccuracy,
-        tags: ['e2e', 'categorization', 'validation']
-    },
-    {
-        name: 'Workflow Instruction Consistency',
-        description: 'Ensures all workflow files use the correct hybrid execution patterns',
-        testFunction: testWorkflowInstructionConsistency,
-        tags: ['e2e', 'consistency', 'workflows']
-    }
-];
-(0, test_utils_1.runTests)(testCases, runEndToEndTest, 'End-to-End Hybrid Validation Tests');

package/dist/tests/test-enhanced-session-init.js

@@ -1,188 +0,0 @@
-"use strict";
-/**
- * Test Enhanced Session Initialization (Issue #40)
- *
- * Verifies that fraim_connect properly captures and stores agent information
- * and provides helpful guidance for machine/repo data collection.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testEnhancedSessionInit = testEnhancedSessionInit;
-const axios_1 = __importDefault(require("axios"));
-const db_service_1 = require("../src/fraim/db-service");
-const shared_server_utils_1 = require("./shared-server-utils");
-const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
-const TEST_API_KEY = 'test-enhanced-session-key';
-async function testEnhancedSessionInit() {
-    console.log('🧪 Testing Enhanced Session Initialization (Issue #40)...');
-    const dbService = new db_service_1.FraimDbService();
-    try {
-        // Wait for server to be ready
-        await (0, shared_server_utils_1.waitForServer)();
-        await dbService.connect();
-        // Set up test API key in database
-        const db = dbService.db;
-        await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
-        await db.collection('fraim_api_keys').insertOne({
-            key: TEST_API_KEY,
-            userId: 'test-user-enhanced-session',
-            orgId: 'test-org',
-            isActive: true,
-            createdAt: new Date()
-        });
-        // Test 1: fraim_connect with complete agent information
-        console.log('   Test 1: Complete agent information...');
-        const completeResponse = await axios_1.default.post(MCP_URL, {
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'tools/call',
-            params: {
-                name: 'fraim_connect',
-                arguments: {
-                    agent: {
-                        name: 'Claude',
-                        model: 'claude-3.5-sonnet',
-                        version: '2024.12.1'
-                    },
-                    machine: {
-                        hostname: 'test-machine',
-                        platform: 'darwin',
-                        memory: 17179869184,
-                        cpus: 8
-                    },
-                    repo: {
-                        url: 'https://github.com/mathursrus/FRAIM.git',
-                        owner: 'mathursrus',
-                        name: 'FRAIM',
-                        branch: 'main'
-                    }
-                }
-            }
-        }, {
-            headers: { 'x-api-key': TEST_API_KEY }
-        });
-        if (completeResponse.status !== 200) {
-            throw new Error(`Expected 200, got ${completeResponse.status}`);
-        }
-        const result = completeResponse.data.result;
-        if (!result.content[0].text.includes('Claude (claude-3.5-sonnet) v2024.12.1')) {
-            throw new Error('Agent information not properly displayed in response');
-        }
-        if (!result.sessionId) {
-            throw new Error('Session ID not returned');
-        }
-        console.log('   ✅ Complete agent information handled correctly');
-        // Test 2: fraim_connect with minimal required information
-        console.log('   Test 2: Minimal required information...');
-        const minimalResponse = await axios_1.default.post(MCP_URL, {
-            jsonrpc: '2.0',
-            id: 2,
-            method: 'tools/call',
-            params: {
-                name: 'fraim_connect',
-                arguments: {
-                    agent: {
-                        name: 'Kiro',
-                        model: 'kiro-agent'
-                    },
-                    machine: {
-                        hostname: 'kiro-machine',
-                        platform: 'win32'
-                    },
-                    repo: {
-                        url: 'https://github.com/test/repo.git'
-                    }
-                }
-            }
-        }, {
-            headers: { 'x-api-key': TEST_API_KEY }
-        });
-        if (minimalResponse.status !== 200) {
-            throw new Error(`Expected 200, got ${minimalResponse.status}`);
-        }
-        const minimalResult = minimalResponse.data.result;
-        if (!minimalResult.content[0].text.includes('Kiro (kiro-agent)')) {
-            throw new Error('Minimal agent information not properly displayed');
-        }
-        console.log('   ✅ Minimal required information handled correctly');
-        // Test 3: fraim_connect missing required agent information
-        console.log('   Test 3: Missing required agent information...');
-        try {
-            await axios_1.default.post(MCP_URL, {
-                jsonrpc: '2.0',
-                id: 3,
-                method: 'tools/call',
-                params: {
-                    name: 'fraim_connect',
-                    arguments: {
-                        agent: {
-                            name: 'Claude'
-                            // Missing required 'model' field
-                        },
-                        machine: {
-                            hostname: 'test-machine',
-                            platform: 'linux'
-                        },
-                        repo: {
-                            url: 'https://github.com/test/repo.git'
-                        }
-                    }
-                }
-            }, {
-                headers: { 'x-api-key': TEST_API_KEY }
-            });
-            throw new Error('Should have failed with missing agent.model');
-        }
-        catch (error) {
-            if (error.response?.data?.error?.message?.includes('Agent information is required')) {
-                console.log('   ✅ Properly rejected missing agent information');
-            }
-            else {
-                throw error;
-            }
-        }
-        // Test 4: Verify agent information is stored in database
-        console.log('   Test 4: Verify database storage...');
-        // We can't easily query sessions without the internal API, but we can verify
-        // the session creation didn't throw errors and returned valid session IDs
-        console.log('   ✅ Database storage verified (sessions created successfully)');
-        console.log('✅ All Enhanced Session Initialization tests passed!');
-        return true;
-    }
-    catch (error) {
-        console.error('❌ Enhanced Session Initialization test failed:', error.message);
-        if (error.response?.data) {
-            console.error('   Response data:', JSON.stringify(error.response.data, null, 2));
-        }
-        return false;
-    }
-    finally {
-        // Clean up
-        if (dbService) {
-            try {
-                const db = dbService.db;
-                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
-                await db.collection('fraim_telemetry_sessions').deleteMany({ userId: 'test-user-enhanced-session' });
-            }
-            catch (e) {
-                // Ignore cleanup errors
-            }
-            await dbService.close();
-        }
-    }
-}
-// Run if called directly
-if (require.main === module) {
-    testEnhancedSessionInit()
-        .then(success => {
-        if (!success) {
-            throw new Error('Test failed');
-        }
-    })
-        .catch(err => {
-        console.error('Test runner error:', err);
-        throw err;
-    });
-}