fraim-framework 2.0.22 → 2.0.26

package/{test-standalone.ts → dist/tests/test-standalone.js}

@@ -1,161 +1,149 @@
-import { spawn, ChildProcess } from 'node:child_process';
-import axios from 'axios';
-import { FraimDbService } from './src/fraim/db-service.js';
-import { BaseTestCase, runTests } from './test-utils';
-import assert from 'node:assert';
-import kill from 'tree-kill';
-
-interface FraimStandaloneTestCase extends BaseTestCase {
-    testFunction: () => Promise<boolean>;
-}
-
-async function testServerStartsAndResponds(): Promise<boolean> {
-    console.log('   🚀 Testing Fraim Standalone Server...');
-    let fraimProcess: ChildProcess | undefined;
-    let dbService: FraimDbService | undefined;
-    const PORT = 10001; // Use a different port to avoid conflicts
-    const TEST_API_KEY = 'test-fraim-key-integration';
-    const TEST_ADMIN_KEY = 'test-admin-key-integration';
-    const TEST_ADMIN_HEADER = { 'x-admin-key': TEST_ADMIN_KEY };
-    const BASE_URL = `http://localhost:${PORT}`;
-
-    try {
-        // 1. Seed the test API key in the database
-        dbService = new FraimDbService();
-        await dbService.connect();
-
-        const db = (dbService as any).db;
-        await db.collection('fraim_api_keys').updateOne(
-            { key: TEST_API_KEY },
-            {
-                $set: {
-                    userId: 'test-user@ashley.ai',
-                    orgId: 'test-org',
-                    isActive: true,
-                    createdAt: new Date()
-                }
-            },
-            { upsert: true }
-        );
-
-        // 2. Start server in standalone mode
-        console.log(`   Starting server on port ${PORT}...`);
-        const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        fraimProcess = spawn(npxCommand, ['tsx', 'src/fraim-mcp-server.ts'], {
-            env: {
-                ...process.env,
-                FRAIM_MCP_PORT: PORT.toString(),
-                FRAIM_ADMIN_KEY: TEST_ADMIN_KEY,
-                FRAIM_SKIP_INDEX_ON_START: 'true' // Potential optimization if implemented
-            },
-            stdio: 'inherit',
-            shell: true
-        });
-
-        // 3. Wait for server to start
-        console.log('   Waiting for server to start...');
-        let started = false;
-        for (let i = 0; i < 15; i++) {
-            try {
-                await axios.get(`${BASE_URL}/health`, { timeout: 1000 });
-                started = true;
-                console.log('   Server started!');
-                break;
-            } catch (e) {
-                await new Promise(resolve => setTimeout(resolve, 1000));
-            }
-        }
-
-        if (!started) {
-            console.error('   ❌ Server failed to start within timeout');
-            return false;
-        }
-
-        // 4. Test health check (public)
-        console.log('   Testing public health check...');
-        const healthRes = await axios.get(`${BASE_URL}/health`, { timeout: 2000 });
-        assert.strictEqual(healthRes.status, 200);
-        assert.strictEqual(healthRes.data.status, 'ok');
-
-        // 5. Test MCP tool list without API key (fail)
-        console.log('   Testing MCP without auth (should fail)...');
-        try {
-            await axios.post(`${BASE_URL}/mcp`, {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'tools/list',
-                params: {}
-            }, { timeout: 2000 });
-            console.error('   ❌ Should have failed without API key');
-            return false;
-        } catch (error: any) {
-            assert.ok(error.response, 'Should have a response');
-            assert.strictEqual(error.response.status, 401);
-        }
-
-        // 6. Test MCP tool list with correct API key (success)
-        console.log('   Testing MCP with correct auth...');
-        const mcpResponse = await axios.post(`${BASE_URL}/mcp`, {
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'tools/list',
-            params: {}
-        }, {
-            headers: { 'x-api-key': TEST_API_KEY },
-            timeout: 5000
-        });
-        assert.strictEqual(mcpResponse.status, 200);
-        assert.ok(mcpResponse.data.result.tools.length > 0);
-
-        // 7. Verify usage logging
-        console.log('   Verifying usage logging...');
-        await new Promise(resolve => setTimeout(resolve, 1500));
-        const log = await db.collection('fraim_usage_logs').findOne({ keyId: TEST_API_KEY });
-        assert.ok(log, 'Usage log should have been created');
-        assert.strictEqual(log.userId, 'test-user@ashley.ai');
-
-        // 8. Test Admin API - List Keys
-        console.log('   Testing Admin API - List Keys...');
-        const listKeysRes = await axios.get(`${BASE_URL}/admin/keys`, {
-            headers: TEST_ADMIN_HEADER,
-            timeout: 2000
-        });
-        assert.strictEqual(listKeysRes.status, 200);
-        assert.ok(Array.isArray(listKeysRes.data));
-        assert.ok(listKeysRes.data.some((k: any) => k.key === TEST_API_KEY));
-
-        return true;
-    } catch (error) {
-        console.error('   ❌ Test failed:', error);
-        return false;
-    } finally {
-        console.log('   Cleaning up...');
-        if (dbService) {
-            const db = (dbService as any).db;
-            if (db) {
-                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY }).catch(() => { });
-            }
-            await dbService.close().catch(() => { });
-        }
-        if (fraimProcess && fraimProcess.pid) {
-            const pid = fraimProcess.pid;
-            await new Promise<void>((resolve) => kill(pid, 'SIGKILL', () => resolve()));
-            console.log(`   Terminated server process ${pid}`);
-        }
-    }
-}
-
-async function runFraimTest(testCase: FraimStandaloneTestCase): Promise<boolean> {
-    return await testCase.testFunction();
-}
-
-const testCases: FraimStandaloneTestCase[] = [
-    {
-        name: 'Fraim Standalone Server Integration',
-        description: 'Tests server startup, public health check, authenticated MCP access, usage logging, and admin API',
-        testFunction: testServerStartsAndResponds,
-        tags: ['smoke', 'fraim']
-    }
-];
-
-runTests(testCases, runFraimTest, 'Fraim Standalone Server');
+"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 axios_1 = __importDefault(require("axios"));
+const db_service_js_1 = require("../src/fraim/db-service.js");
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const path_1 = __importDefault(require("path"));
+async function testServerStartsAndResponds() {
+    console.log('   🚀 Testing Fraim Standalone Server...');
+    let fraimProcess;
+    let dbService;
+    const PORT = 10001; // Use a different port to avoid conflicts
+    const TEST_API_KEY = 'test-fraim-key-integration';
+    const TEST_ADMIN_KEY = 'test-admin-key-integration';
+    const TEST_ADMIN_HEADER = { 'x-admin-key': TEST_ADMIN_KEY };
+    const BASE_URL = `http://localhost:${PORT}`;
+    try {
+        // 1. Seed the test API key in the database
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        const db = dbService.db;
+        await db.collection('fraim_api_keys').updateOne({ key: TEST_API_KEY }, {
+            $set: {
+                userId: 'test-user@ashley.ai',
+                orgId: 'test-org',
+                isActive: true,
+                createdAt: new Date()
+            }
+        }, { upsert: true });
+        // 2. Start server in standalone mode
+        console.log(`   Starting server on port ${PORT}...`);
+        const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+        const serverScript = path_1.default.resolve(__dirname, '../src/fraim-mcp-server.ts');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${serverScript}"`], {
+            env: {
+                ...process.env,
+                FRAIM_MCP_PORT: PORT.toString(),
+                FRAIM_ADMIN_KEY: TEST_ADMIN_KEY,
+                FRAIM_SKIP_INDEX_ON_START: 'true' // Potential optimization if implemented
+            },
+            stdio: 'inherit',
+            shell: true
+        });
+        // 3. Wait for server to start
+        console.log('   Waiting for server to start...');
+        let started = false;
+        for (let i = 0; i < 15; i++) {
+            try {
+                await axios_1.default.get(`${BASE_URL}/health`, { timeout: 1000 });
+                started = true;
+                console.log('   Server started!');
+                break;
+            }
+            catch (e) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+        if (!started) {
+            console.error('   ❌ Server failed to start within timeout');
+            return false;
+        }
+        // 4. Test health check (public)
+        console.log('   Testing public health check...');
+        const healthRes = await axios_1.default.get(`${BASE_URL}/health`, { timeout: 2000 });
+        node_assert_1.default.strictEqual(healthRes.status, 200);
+        node_assert_1.default.strictEqual(healthRes.data.status, 'ok');
+        // 5. Test MCP tool list without API key (fail)
+        console.log('   Testing MCP without auth (should fail)...');
+        try {
+            await axios_1.default.post(`${BASE_URL}/mcp`, {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/list',
+                params: {}
+            }, { timeout: 2000 });
+            console.error('   ❌ Should have failed without API key');
+            return false;
+        }
+        catch (error) {
+            node_assert_1.default.ok(error.response, 'Should have a response');
+            node_assert_1.default.strictEqual(error.response.status, 401);
+        }
+        // 6. Test MCP tool list with correct API key (success)
+        console.log('   Testing MCP with correct auth...');
+        const mcpResponse = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/list',
+            params: {}
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY },
+            timeout: 5000
+        });
+        node_assert_1.default.strictEqual(mcpResponse.status, 200);
+        node_assert_1.default.ok(mcpResponse.data.result.tools.length > 0);
+        // 7. Verify usage logging
+        console.log('   Verifying usage logging...');
+        await new Promise(resolve => setTimeout(resolve, 1500));
+        const log = await db.collection('fraim_usage_logs').findOne({ keyId: TEST_API_KEY });
+        node_assert_1.default.ok(log, 'Usage log should have been created');
+        node_assert_1.default.strictEqual(log.userId, 'test-user@ashley.ai');
+        // 8. Test Admin API - List Keys
+        console.log('   Testing Admin API - List Keys...');
+        const listKeysRes = await axios_1.default.get(`${BASE_URL}/admin/keys`, {
+            headers: TEST_ADMIN_HEADER,
+            timeout: 2000
+        });
+        node_assert_1.default.strictEqual(listKeysRes.status, 200);
+        node_assert_1.default.ok(Array.isArray(listKeysRes.data));
+        node_assert_1.default.ok(listKeysRes.data.some((k) => k.key === TEST_API_KEY));
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error);
+        return false;
+    }
+    finally {
+        console.log('   Cleaning up...');
+        if (dbService) {
+            const db = dbService.db;
+            if (db) {
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY }).catch(() => { });
+            }
+            await dbService.close().catch(() => { });
+        }
+        if (fraimProcess && fraimProcess.pid) {
+            const pid = fraimProcess.pid;
+            await new Promise((resolve) => (0, tree_kill_1.default)(pid, 'SIGKILL', () => resolve()));
+            console.log(`   Terminated server process ${pid}`);
+        }
+    }
+}
+async function runFraimTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Fraim Standalone Server Integration',
+        description: 'Tests server startup, public health check, authenticated MCP access, usage logging, and admin API',
+        testFunction: testServerStartsAndResponds,
+        tags: ['smoke', 'fraim']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runFraimTest, 'Fraim Standalone Server');

package/dist/tests/test-user-journey.js

@@ -0,0 +1,231 @@
+"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 axios_1 = __importDefault(require("axios"));
+const test_utils_1 = require("./test-utils");
+const db_service_1 = require("../src/fraim/db-service");
+const node_assert_1 = __importDefault(require("node:assert"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function testDualDiscoveryJourney() {
+    console.log('   🚀 Starting Dual Discovery User Journey Test...');
+    // Setup
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-journey-'));
+    console.log(`   📂 Project Context: ${tempDir}`);
+    let fraimProcess;
+    let dbService;
+    const PORT = 10004;
+    const BASE_URL = `http://localhost:${PORT}`;
+    const TEST_API_KEY = 'fraim-journey-key';
+    try {
+        // --- PRE-REQUISITE: DB Setup ---
+        dbService = new db_service_1.FraimDbService();
+        await dbService.connect();
+        const db = dbService.db;
+        await db.collection('fraim_api_keys').updateOne({ key: TEST_API_KEY }, { $set: { userId: 'journey-user', orgId: 'journey-org', isActive: true } }, { upsert: true });
+        // --- SCENARIO 1: Project Initialization ---
+        console.log('\n   [1/4] Scenario: User initializes project');
+        // Mock registry in the repo for sync to work
+        // We will point the test to use the repo's actual registry folder
+        // But for 'init' we just need the script
+        const cliScript = path_1.default.resolve(__dirname, '../src/cli/fraim.ts');
+        const tsxCli = path_1.default.resolve(__dirname, '../node_modules/tsx/dist/cli.mjs');
+        const runFraim = async (args) => {
+            return new Promise(resolve => {
+                const ps = (0, node_child_process_1.spawn)(process.execPath, [tsxCli, cliScript, ...args], {
+                    cwd: tempDir,
+                    env: { ...process.env, TEST_MODE: 'true' },
+                    shell: false
+                });
+                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({ code, stdout: stdout + '\nSTDERR:\n' + stderr }));
+            });
+        };
+        const initRes = await runFraim(['init']);
+        node_assert_1.default.strictEqual(initRes.code, 0, 'Init failed');
+        node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(tempDir, '.fraim', 'config.json')), 'Config missing');
+        console.log('   ✅ `fraim init` created project structure');
+        // --- SEED REGISTRY ---
+        // The CLI sync command looks for 'registry' in the project root if it can't find it relative to the script.
+        // We simulate a valid environment by copying the registry to the temp project.
+        const sourceRegistry = path_1.default.join(__dirname, '../registry');
+        const targetRegistry = path_1.default.join(tempDir, 'registry');
+        // Simple recursive copy helper
+        const copyRecursiveSync = (src, dest) => {
+            if (fs_1.default.existsSync(src)) {
+                if (fs_1.default.lstatSync(src).isDirectory()) {
+                    if (!fs_1.default.existsSync(dest))
+                        fs_1.default.mkdirSync(dest);
+                    fs_1.default.readdirSync(src).forEach(child => {
+                        copyRecursiveSync(path_1.default.join(src, child), path_1.default.join(dest, child));
+                    });
+                }
+                else {
+                    fs_1.default.copyFileSync(src, dest);
+                }
+            }
+        };
+        copyRecursiveSync(sourceRegistry, targetRegistry);
+        console.log('   📂 Seeded test registry');
+        // --- SCENARIO 2: Workflow Discovery (Stubbing) ---
+        console.log('\n   [2/4] Scenario: User expects stubs for discovery');
+        // Create a fake registry workflow to test syncing
+        // The registry is now seeded in tempDir/registry, so sync should find it via fallback.
+        const syncRes = await runFraim(['sync']);
+        if (syncRes.code !== 0) {
+            console.error('   ❌ Sync failed. Output:', syncRes.stdout);
+            // Spawn helper above captures stdout/stderr mixed or just stdout? 
+            // The helper captures stdout from ps.stdout and ignore stderr?
+            // Let's check helper.
+        }
+        node_assert_1.default.strictEqual(syncRes.code, 0, 'Sync failed');
+        // Verify Stub Content
+        // The registry has 'product-building/design.md'. 
+        // Sync should now preserve the 'product-building/' folder.
+        const localWorkflowsDir = path_1.default.join(tempDir, '.fraim', 'workflows');
+        if (!fs_1.default.existsSync(localWorkflowsDir))
+            fs_1.default.mkdirSync(localWorkflowsDir, { recursive: true });
+        // Check specifically for the nested file
+        // We know 'design.md' is inside 'product-building' in the registry
+        // Wait, where is 'product-building/design.md' in the source registry provided to the test?
+        // In Step 1, we recursively copied 'registry' to 'tempDir/registry'.
+        // If the source registry has 'workflows/product-building/design.md', then sync should produce '.fraim/workflows/product-building/design.md'.
+        // Let's verify recursively
+        const countFiles = (dir) => {
+            let count = 0;
+            if (!fs_1.default.existsSync(dir))
+                return 0;
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const e of entries) {
+                if (e.isDirectory())
+                    count += countFiles(path_1.default.join(dir, e.name));
+                else if (e.name.endsWith('.md'))
+                    count++;
+            }
+            return count;
+        };
+        const fileCount = countFiles(localWorkflowsDir);
+        node_assert_1.default.ok(fileCount > 0, 'No stubs generated');
+        // Check content of one file
+        const findFirstStub = (dir) => {
+            if (!fs_1.default.existsSync(dir))
+                return null;
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const e of entries) {
+                if (e.isDirectory()) {
+                    const f = findFirstStub(path_1.default.join(dir, e.name));
+                    if (f)
+                        return f;
+                }
+                else if (e.name.endsWith('.md'))
+                    return path_1.default.join(dir, e.name);
+            }
+            return null;
+        };
+        const firstStubPath = findFirstStub(localWorkflowsDir);
+        if (firstStubPath) {
+            const stubContent = fs_1.default.readFileSync(firstStubPath, 'utf8');
+            node_assert_1.default.ok(stubContent.includes('## Intent'), 'Stub missing intent header');
+            const intentContent = stubContent.match(/## Intent\n([\s\S]*?)$/)?.[1]?.trim();
+            node_assert_1.default.ok(intentContent && intentContent !== 'No intent defined.', `Intent should be populated, found fallback in ${firstStubPath}`);
+            node_assert_1.default.ok(intentContent && intentContent.length > 20, `Intent too short in ${firstStubPath}`);
+            node_assert_1.default.ok(!stubContent.includes('Core Principles'), 'Stub should NOT have detailed principles');
+            node_assert_1.default.ok(stubContent.includes('DO NOT EXECUTE'), 'Stub must warn agent');
+            node_assert_1.default.ok(!stubContent.includes('Commit this file'), 'Stub footer should be removed');
+            console.log(`   ✅ "fraim sync" generated ${fileCount} lightweight stubs (Verified content & structure)`);
+        }
+        else {
+            throw new Error('No stubs found to verify content');
+        }
+        // --- SCENARIO 3: Agent Interaction (Version Check) ---
+        console.log('\n   [3/4] Scenario: Agent connects to MCP Server');
+        // Start Server in the project context
+        // Mock a mismatched version in package.json
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify({
+            dependencies: { "@fraim/framework": "1.0.0" }
+        }));
+        const serverScript = path_1.default.resolve(__dirname, '../src/fraim-mcp-server.ts');
+        fraimProcess = (0, node_child_process_1.spawn)(process.execPath, [tsxCli, serverScript], {
+            cwd: tempDir,
+            env: { ...process.env, FRAIM_MCP_PORT: PORT.toString(), FRAIM_SKIP_INDEX_ON_START: 'true' },
+            stdio: 'pipe', // Quiet outcome
+            shell: false
+        });
+        let serverLog = '';
+        if (fraimProcess.stdout)
+            fraimProcess.stdout.on('data', d => serverLog += d.toString());
+        if (fraimProcess.stderr)
+            fraimProcess.stderr.on('data', d => serverLog += d.toString());
+        // Loop wait for health
+        let active = false;
+        for (let i = 0; i < 60; i++) {
+            try {
+                await axios_1.default.get(`${BASE_URL}/health`);
+                active = true;
+                break;
+            }
+            catch {
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+        if (!active) {
+            console.error('❌ Server failed to start. Logs:\n', serverLog);
+            throw new Error('Server failed to start');
+        }
+        // Test Version Header on Root Endpoint
+        const mcpRes = await axios_1.default.post(`${BASE_URL}/`, {
+            jsonrpc: '2.0', id: 1, method: 'initialize', params: {}
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        node_assert_1.default.ok(mcpRes.headers['x-fraim-version-notice'], 'Missing Version Notice Header');
+        console.log('   ✅ Server detected version mismatch and sent guidance header');
+        // --- SCENARIO 4: Upgrade Guidance (Tool Result) ---
+        console.log('\n   [4/4] Scenario: Agent executes tool with outdated version');
+        // Call a tool (e.g., list_tools is simple)
+        const toolRes = await axios_1.default.post(`${BASE_URL}/`, {
+            jsonrpc: '2.0', id: 2, method: 'tools/list', params: {}
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        // The middleware injects the notice into the request. 
+        // The handler `handleToolCall` or logic usually injects it into CONTENT.
+        // `tools/list` might not return 'content'. `handleToolCall` does.
+        // Let's call a tool that doesn't really exist or fails? 
+        // Actually `versionCheck` middleware puts it in a header always.
+        // Logic in `handleToolCall` injects it into text content.
+        // Let's try to simulate a tool call. We need a valid tool or mocked one. 
+        // We can check if the header persists.
+        node_assert_1.default.ok(toolRes.headers['x-fraim-version-notice'], 'Header missing on tool call');
+        console.log('   ✅ Guidance persists on tool execution');
+        return true;
+    }
+    catch (e) {
+        console.error('   ❌ User Journey Logic Failed:', e);
+        return false;
+    }
+    finally {
+        if (dbService)
+            await dbService.close();
+        if (fraimProcess?.pid) {
+            await new Promise((resolve) => (0, tree_kill_1.default)(fraimProcess.pid, 'SIGKILL', () => resolve()));
+        }
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+async function runJourney(testCase) {
+    return await testCase.testFunction();
+}
+(0, test_utils_1.runTests)([{
+        name: 'Dual Discovery User Journey',
+        description: 'End-to-End verification of the Developer -> Agent -> Framework loop',
+        testFunction: testDualDiscoveryJourney,
+        tags: ['e2e', 'journey']
+    }], runJourney, 'Fraim User Journey');

package/dist/tests/test-utils.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTests = runTests;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config({ override: true });
+const node_test_1 = require("node:test");
+// Global tracker for failed tests across all suites
+const globalFailedTests = [];
+// Generic test runner function that can run any type of test
+async function runTests(testCases, runTestFn, testTitle) {
+    console.log(`🧪 Testing ${testTitle}...\n`);
+    // Check if we need to filter by tags
+    let tagsFilter = [];
+    console.log(`Command line arguments: ${process.argv.join(', ')}`);
+    // First try command line arguments
+    const tagsArg = process.argv.find(arg => arg && typeof arg === 'string' && arg.startsWith('--tags='));
+    if (tagsArg) {
+        const tagValue = tagsArg.split('=')[1];
+        if (tagValue) {
+            tagsFilter = tagValue.split(',');
+            console.log(`Filtering tests by tags (from CLI): ${tagsFilter.join(', ')}`);
+        }
+    }
+    // Then try environment variable (for npm scripts)
+    if (tagsFilter.length === 0 && process.env.TAGS) {
+        tagsFilter = process.env.TAGS.split(',');
+        console.log(`Filtering tests by tags (from ENV): ${tagsFilter.join(', ')}`);
+    }
+    // Check for exclusion tags
+    let excludeTags = [];
+    if (process.env.EXCLUDE_TAGS) {
+        excludeTags = process.env.EXCLUDE_TAGS.split(',');
+        console.log(`Excluding tests with tags (from ENV): ${excludeTags.join(', ')}`);
+    }
+    // Filter test cases by tags if specified
+    const testsToRun = testCases.filter(test => {
+        // First check inclusion filter
+        if (tagsFilter.length > 0) {
+            // Ensure test.tags exists before calling .some() on it
+            if (!test.tags || !test.tags.some(tag => tagsFilter.includes(tag))) {
+                return false;
+            }
+        }
+        // Then check exclusion filter
+        if (excludeTags.length > 0) {
+            // Exclude tests with specified tags
+            if (test.tags && test.tags.some(tag => excludeTags.includes(tag))) {
+                return false;
+            }
+        }
+        return true;
+    });
+    if (testsToRun.length === 0) {
+        console.log('No tests to run for suite: ' + testTitle);
+        return;
+    }
+    console.log(`Running ${testsToRun.length} tests${tagsFilter.length > 0 ? ` with tags: ${tagsFilter.join(', ')}` : ''}\n`);
+    // Use Node.js built-in test() function for each test case
+    // This allows the TAP reporter to properly aggregate results across all test files
+    for (const testCase of testsToRun) {
+        await (0, node_test_1.test)(testCase.name, async () => {
+            try {
+                const success = await runTestFn(testCase);
+                if (!success) {
+                    const failedTestName = `${testTitle}: ${testCase.name}`;
+                    if (!globalFailedTests.includes(failedTestName)) {
+                        globalFailedTests.push(failedTestName);
+                    }
+                    throw new Error(`Test failed: ${testCase.name}`);
+                }
+            }
+            catch (error) {
+                const failedTestName = `${testTitle}: ${testCase.name}`;
+                if (!globalFailedTests.includes(failedTestName)) {
+                    globalFailedTests.push(failedTestName);
+                }
+                throw error;
+            }
+        });
+    }
+    // Display comprehensive final summary
+    console.log(`\n🚨 FINAL TEST SUMMARY:`);
+    console.log(`   ❌ Total Failed Tests: ${globalFailedTests.length}`);
+    if (globalFailedTests.length > 0) {
+        console.log(`   📋 Failed Test Names:`);
+        globalFailedTests.forEach(testName => {
+            console.log(`   - ${testName}`);
+        });
+    }
+    if (globalFailedTests.length > 0) {
+        process.exitCode = 1;
+    }
+}