fraim-framework 2.0.36 → 2.0.38

package/dist/tests/test-mcp-shared-server.js

@@ -0,0 +1,308 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const db_service_js_1 = require("../src/fraim/db-service.js");
+const shared_server_utils_1 = require("./shared-server-utils");
+// Test 1: Basic Connection
+async function testBasicConnection() {
+    console.log('   🧪 Testing basic MCP connection...');
+    const BASE_URL = (0, shared_server_utils_1.getTestServerUrl)();
+    const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
+    const TEST_API_KEY = 'test-fraim-key-shared-basic';
+    let dbService;
+    try {
+        // Wait for server to be ready
+        await (0, shared_server_utils_1.waitForServer)();
+        // Setup test API key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        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-shared-basic',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        // Test health endpoint
+        const healthRes = await axios_1.default.get(`${BASE_URL}/health`);
+        node_assert_1.default.strictEqual(healthRes.status, 200);
+        // Test MCP endpoint with initialize
+        const initRes = await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: {}
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        node_assert_1.default.strictEqual(initRes.status, 200);
+        node_assert_1.default.strictEqual(initRes.data.jsonrpc, '2.0');
+        console.log('   ✅ Basic connection test passed');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Basic connection test failed:', error.message);
+        return false;
+    }
+    finally {
+        if (dbService) {
+            try {
+                const db = dbService.db;
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+                await dbService.close();
+            }
+            catch (e) {
+                console.warn('   ⚠️ DB cleanup failed:', e);
+            }
+        }
+    }
+}
+// Test 2: Tools List
+async function testToolsList() {
+    console.log('   🧪 Testing tools/list endpoint...');
+    const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
+    const TEST_API_KEY = 'test-fraim-key-shared-tools';
+    let dbService;
+    try {
+        // Wait for server to be ready
+        await (0, shared_server_utils_1.waitForServer)();
+        // Setup test API key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        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-shared-tools',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        const res = await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'tools/list',
+            params: {}
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        node_assert_1.default.strictEqual(res.status, 200);
+        node_assert_1.default.strictEqual(res.data.jsonrpc, '2.0');
+        (0, node_assert_1.default)(Array.isArray(res.data.result.tools), 'Should return tools array');
+        console.log(`   ✅ Tools list returned ${res.data.result.tools.length} tools`);
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Tools list test failed:', error.message);
+        return false;
+    }
+    finally {
+        if (dbService) {
+            try {
+                const db = dbService.db;
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+                await dbService.close();
+            }
+            catch (e) {
+                console.warn('   ⚠️ DB cleanup failed:', e);
+            }
+        }
+    }
+}
+// Test 3: Tool Call
+async function testToolCall() {
+    console.log('   🧪 Testing tool call (get_fraim_init)...');
+    const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
+    const TEST_API_KEY = 'test-fraim-key-shared-call';
+    let dbService;
+    try {
+        // Wait for server to be ready
+        await (0, shared_server_utils_1.waitForServer)();
+        // Setup test API key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        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-shared-call',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        const res = await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 3,
+            method: 'tools/call',
+            params: {
+                name: 'get_fraim_init',
+                arguments: {}
+            }
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        node_assert_1.default.strictEqual(res.status, 200);
+        node_assert_1.default.strictEqual(res.data.jsonrpc, '2.0');
+        (0, node_assert_1.default)(res.data.result, 'Should return result');
+        console.log('   ✅ Tool call test passed');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Tool call test failed:', error.message);
+        return false;
+    }
+    finally {
+        if (dbService) {
+            try {
+                const db = dbService.db;
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+                await dbService.close();
+            }
+            catch (e) {
+                console.warn('   ⚠️ DB cleanup failed:', e);
+            }
+        }
+    }
+}
+// Test 4: Error Handling
+async function testErrorHandling() {
+    console.log('   🧪 Testing error handling...');
+    const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
+    const TEST_API_KEY = 'test-fraim-key-shared-error';
+    let dbService;
+    try {
+        // Wait for server to be ready
+        await (0, shared_server_utils_1.waitForServer)();
+        // Setup test API key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        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-shared-error',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        // Test invalid method
+        const res = await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 4,
+            method: 'invalid/method',
+            params: {}
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY },
+            validateStatus: () => true // Don't throw on error status
+        });
+        // Should return error response, not crash
+        (0, node_assert_1.default)(res.data.error, 'Should return error for invalid method');
+        console.log('   ✅ Error handling test passed');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Error handling test failed:', error.message);
+        return false;
+    }
+    finally {
+        if (dbService) {
+            try {
+                const db = dbService.db;
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+                await dbService.close();
+            }
+            catch (e) {
+                console.warn('   ⚠️ DB cleanup failed:', e);
+            }
+        }
+    }
+}
+// Test 5: Concurrent Requests
+async function testConcurrentRequests() {
+    console.log('   🧪 Testing concurrent requests...');
+    const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
+    const TEST_API_KEY = 'test-fraim-key-shared-concurrent';
+    let dbService;
+    try {
+        // Wait for server to be ready
+        await (0, shared_server_utils_1.waitForServer)();
+        // Setup test API key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        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-shared-concurrent',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        const requests = Array.from({ length: 5 }, (_, i) => axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 10 + i,
+            method: 'tools/list',
+            params: {}
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        }));
+        const responses = await Promise.all(requests);
+        responses.forEach((res, i) => {
+            node_assert_1.default.strictEqual(res.status, 200, `Request ${i} should succeed`);
+            node_assert_1.default.strictEqual(res.data.id, 10 + i, `Request ${i} should have correct ID`);
+        });
+        console.log('   ✅ Concurrent requests test passed');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Concurrent requests test failed:', error.message);
+        return false;
+    }
+    finally {
+        if (dbService) {
+            try {
+                const db = dbService.db;
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+                await dbService.close();
+            }
+            catch (e) {
+                console.warn('   ⚠️ DB cleanup failed:', e);
+            }
+        }
+    }
+}
+const testCases = [
+    {
+        name: 'Basic Connection',
+        testFunction: testBasicConnection
+    },
+    {
+        name: 'Tools List',
+        testFunction: testToolsList
+    },
+    {
+        name: 'Tool Call',
+        testFunction: testToolCall
+    },
+    {
+        name: 'Error Handling',
+        testFunction: testErrorHandling
+    },
+    {
+        name: 'Concurrent Requests',
+        testFunction: testConcurrentRequests
+    }
+];
+// Custom test runner function for shared MCP tests
+async function runSharedMcpTest(testCase) {
+    return await testCase.testFunction();
+}
+// Use the standard test runner with the shared server
+(0, test_utils_1.runTests)(testCases, runSharedMcpTest, 'Shared MCP Server Tests');

package/dist/tests/test-npm-resolution-diagnostic.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Diagnostic test to understand npm's chalk resolution behavior
+ *
+ * This test will show us exactly what npm does when there's a version conflict
+ */
+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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function main() {
+    console.log('🔍 NPM Chalk Resolution Diagnostic\n');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'npm-diagnostic-'));
+    console.log(`📂 Temp dir: ${tempDir}\n`);
+    try {
+        // 1. Pack fraim-framework
+        console.log('📦 Packing fraim-framework...');
+        const projectRoot = process.cwd();
+        const packResult = (0, node_child_process_1.execSync)('npm pack', {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        const tarballName = packResult.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            console.log('❌ Failed to pack');
+            return;
+        }
+        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        console.log(`✅ Created: ${tarballName}\n`);
+        // 2. Create test project with chalk v5
+        console.log('📝 Creating test project with chalk v5 dependency...');
+        const packageJson = {
+            name: 'diagnostic-test',
+            version: '1.0.0',
+            dependencies: {
+                'chalk': '^5.0.0',
+                'fraim-framework': `file:${tarballPath}`
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+        // 3. Install
+        console.log('📥 Running npm install...\n');
+        try {
+            const installOutput = (0, node_child_process_1.execSync)('npm install', {
+                cwd: tempDir,
+                encoding: 'utf-8',
+                stdio: 'pipe'
+            });
+            console.log('✅ Install completed\n');
+        }
+        catch (error) {
+            console.log('⚠️  Install had issues:\n', error.stdout || error.message);
+        }
+        // 4. Check what was installed
+        console.log('📋 Checking installed chalk versions...\n');
+        // Root chalk
+        const rootChalkPath = path_1.default.join(tempDir, 'node_modules', 'chalk', 'package.json');
+        if (fs_1.default.existsSync(rootChalkPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(rootChalkPath, 'utf-8'));
+            console.log(`  Root chalk: ${pkg.version}`);
+            console.log(`  Type: ${pkg.type || 'commonjs'}`);
+            console.log(`  Main: ${pkg.main || 'N/A'}`);
+            console.log(`  Exports: ${pkg.exports ? 'Yes' : 'No'}\n`);
+        }
+        else {
+            console.log('  ❌ No root chalk found\n');
+        }
+        // Fraim's chalk
+        const fraimChalkPath = path_1.default.join(tempDir, 'node_modules', 'fraim-framework', 'node_modules', 'chalk', 'package.json');
+        if (fs_1.default.existsSync(fraimChalkPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(fraimChalkPath, 'utf-8'));
+            console.log(`  fraim-framework's chalk: ${pkg.version}`);
+            console.log(`  Type: ${pkg.type || 'commonjs'}`);
+            console.log(`  Main: ${pkg.main || 'N/A'}\n`);
+        }
+        else {
+            console.log('  ℹ️  fraim-framework has no separate chalk (using root)\n');
+        }
+        // 5. Run npm ls to see the dependency tree
+        console.log('🌳 Dependency tree (npm ls chalk):\n');
+        try {
+            const lsOutput = (0, node_child_process_1.execSync)('npm ls chalk', {
+                cwd: tempDir,
+                encoding: 'utf-8'
+            });
+            console.log(lsOutput);
+        }
+        catch (error) {
+            console.log(error.stdout || error.message);
+        }
+        // 6. Check fraim-framework's package.json in node_modules
+        console.log('\n📋 fraim-framework\'s chalk dependency in node_modules:\n');
+        const fraimPkgPath = path_1.default.join(tempDir, 'node_modules', 'fraim-framework', 'package.json');
+        if (fs_1.default.existsSync(fraimPkgPath)) {
+            const fraimPkg = JSON.parse(fs_1.default.readFileSync(fraimPkgPath, 'utf-8'));
+            console.log(`  Chalk version in package.json: ${fraimPkg.dependencies?.chalk || 'N/A'}\n`);
+        }
+        // 7. Try to load fraim CLI
+        console.log('🚀 Testing fraim CLI load...\n');
+        const testScript = `
+try {
+    const fraimCli = require('./node_modules/fraim-framework/dist/src/cli/fraim.js');
+    console.log('✅ SUCCESS: fraim CLI loaded');
+} catch (error) {
+    console.log('❌ ERROR:', error.code || 'Unknown');
+    console.log('Message:', error.message.substring(0, 200));
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        try {
+            const testOutput = (0, node_child_process_1.execSync)('node test.js', {
+                cwd: tempDir,
+                encoding: 'utf-8'
+            });
+            console.log(testOutput);
+        }
+        catch (error) {
+            console.log(error.stdout || error.message);
+        }
+        // Cleanup
+        fs_1.default.unlinkSync(tarballPath);
+        console.log('\n✅ Diagnostic complete');
+    }
+    catch (error) {
+        console.error('\n❌ Diagnostic failed:', error);
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) {
+            console.log('\n⚠️  Could not clean up temp directory');
+        }
+    }
+}
+main();

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

@@ -0,0 +1,101 @@
+#!/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');
+    (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');
+    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-prep-issue.js

@@ -57,7 +57,7 @@ async function verifyPrepIssueConfigParsing() {
             }
         };
         const output = runParsingLogic(nodeScript, validConfig);
-        assert_1.default.strictEqual(output, 'test-owner:test-repo:https://github.com/test-owner/test-repo.git');
+        assert_1.default.strictEqual(output, 'test-owner|test-repo|https://github.com/test-owner/test-repo.git|master');
         console.log('   ✅ Valid config parsed correctly');
         // 4. Test Missing Config
         assert_1.default.throws(() => {
@@ -69,6 +69,39 @@ async function verifyPrepIssueConfigParsing() {
             runParsingLogic(nodeScript, { repository: { owner: 'test-owner' } });
         }, /Script failed/);
         console.log('   ✅ Incomplete config correctly failed');
+        // 6. Test Default Branch Extraction (git schema)
+        const gitConfig = {
+            git: {
+                repoOwner: 'test-owner',
+                repoName: 'test-repo',
+                defaultBranch: 'master'
+            }
+        };
+        const gitOutput = runParsingLogic(nodeScript, gitConfig);
+        assert_1.default.strictEqual(gitOutput, 'test-owner|test-repo|https://github.com/test-owner/test-repo.git|master');
+        console.log('   ✅ Git config with defaultBranch parsed correctly');
+        // 7. Test Default Branch Extraction (repository schema)
+        const repoConfig = {
+            repository: {
+                owner: 'test-owner',
+                name: 'test-repo',
+                url: 'https://github.com/test-owner/test-repo.git',
+                defaultBranch: 'main'
+            }
+        };
+        const repoOutput = runParsingLogic(nodeScript, repoConfig);
+        assert_1.default.strictEqual(repoOutput, 'test-owner|test-repo|https://github.com/test-owner/test-repo.git|main');
+        console.log('   ✅ Repository config with defaultBranch parsed correctly');
+        // 8. Test Default Branch Fallback
+        const noDefaultConfig = {
+            git: {
+                repoOwner: 'test-owner',
+                repoName: 'test-repo'
+            }
+        };
+        const fallbackOutput = runParsingLogic(nodeScript, noDefaultConfig);
+        assert_1.default.strictEqual(fallbackOutput, 'test-owner|test-repo|https://github.com/test-owner/test-repo.git|master');
+        console.log('   ✅ Default branch fallback to master works correctly');
         return true;
     }
     catch (error) {