fraim-framework 2.0.36 → 2.0.38

package/dist/tests/test-script-location-independence.js

@@ -42,13 +42,15 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 async function testScriptLocationIndependence() {
     console.log('   🚀 Testing Script Location Independence...');
-    const tempProjectDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-location-test-'));
-    const userFraimDir = path_1.default.join(os_1.default.homedir(), '.fraim-location-test');
+    // Use timestamp to ensure unique directories even in concurrent runs
+    const timestamp = Date.now();
+    const tempProjectDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `fraim-location-test-${timestamp}-`));
+    const userFraimDir = path_1.default.join(os_1.default.homedir(), `.fraim-location-test-${timestamp}`);
     const userScriptsDir = path_1.default.join(userFraimDir, 'scripts');
     console.log(`   📂 Created temp project dir: ${tempProjectDir}`);
     console.log(`   🏠 Using test user dir: ${userFraimDir}`);
     try {
-        // Clean up any existing test user directory
+        // Clean up any existing test user directory (with timestamp, should be unique)
         if (fs_1.default.existsSync(userFraimDir)) {
             fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
         }
@@ -75,11 +77,11 @@ async function testScriptLocationIndependence() {
         const projectFraimDir = path_1.default.join(tempProjectDir, '.fraim');
         fs_1.default.mkdirSync(projectFraimDir, { recursive: true });
         const testConfig = {
-            project: { name: 'location-test' },
+            project: { name: `location-test-${timestamp}` },
             git: {
                 repoOwner: 'test',
-                repoName: 'location-test',
-                url: 'https://github.com/test/location-test.git'
+                repoName: `location-test-${timestamp}`,
+                url: `https://github.com/test/location-test-${timestamp}.git`
             }
         };
         fs_1.default.writeFileSync(path_1.default.join(projectFraimDir, 'config.json'), JSON.stringify(testConfig, null, 2));
@@ -111,7 +113,7 @@ async function testScriptLocationIndependence() {
                     const output = execSync(bashCommand, {
                         cwd: tempProjectDir,
                         encoding: 'utf-8',
-                        timeout: 10000
+                        timeout: 15000 // Increased timeout for concurrent runs
                     });
                 }
                 else {
@@ -119,13 +121,18 @@ async function testScriptLocationIndependence() {
                     const output = execSync(`"${prepIssueScript}" --help`, {
                         cwd: tempProjectDir,
                         encoding: 'utf-8',
-                        timeout: 10000
+                        timeout: 15000 // Increased timeout for concurrent runs
                     });
                 }
                 // If we get here, the script at least started successfully
                 console.log('   ✅ prep-issue.sh executed successfully from user directory');
             }
             catch (error) {
+                // Check for timeout specifically
+                if (error.message.includes('ETIMEDOUT') || error.signal === 'SIGTERM') {
+                    console.log('   ❌ prep-issue.sh failed: spawnSync', error.syscall, 'ETIMEDOUT');
+                    return false;
+                }
                 // The script may fail due to missing repo, but as long as it started, that's OK
                 if (error.message.includes('Repository not found') ||
                     error.message.includes('fatal: repository') ||
@@ -142,54 +149,7 @@ async function testScriptLocationIndependence() {
         else {
             console.log('   ⚠️ prep-issue.sh not found, skipping test');
         }
-        // Test 2: Try to execute code-quality-check.sh (this will likely fail due to dependencies)
-        console.log('   Testing code-quality-check.sh execution from user directory...');
-        const qualityCheckScript = path_1.default.join(userScriptsDir, 'code-quality-check.sh');
-        if (fs_1.default.existsSync(qualityCheckScript)) {
-            try {
-                const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-                if (process.platform === 'win32') {
-                    const gitBashPaths = [
-                        'C:\\Program Files\\Git\\bin\\bash.exe',
-                        'C:\\Program Files (x86)\\Git\\bin\\bash.exe'
-                    ];
-                    let bashPath = null;
-                    for (const path of gitBashPaths) {
-                        if (fs_1.default.existsSync(path)) {
-                            bashPath = path;
-                            break;
-                        }
-                    }
-                    if (!bashPath) {
-                        console.log('   ⚠️ Git Bash not found on Windows, skipping quality check test');
-                    }
-                    else {
-                        const bashCommand = `"${bashPath}" "${qualityCheckScript}" --help`;
-                        const output = execSync(bashCommand, {
-                            cwd: tempProjectDir,
-                            encoding: 'utf-8',
-                            timeout: 10000
-                        });
-                        console.log('   ✅ code-quality-check.sh executed successfully from user directory');
-                    }
-                }
-                else {
-                    const output = execSync(`"${qualityCheckScript}" --help`, {
-                        cwd: tempProjectDir,
-                        encoding: 'utf-8',
-                        timeout: 10000
-                    });
-                    console.log('   ✅ code-quality-check.sh executed successfully from user directory');
-                }
-            }
-            catch (error) {
-                console.log('   ❌ code-quality-check.sh failed (expected due to dependencies):', error.message);
-                // This is expected to fail - we'll document this as a known issue
-            }
-        }
-        else {
-            console.log('   ⚠️ code-quality-check.sh not found, skipping test');
-        }
+        // Skip the second test to reduce interference - the first test is sufficient
         console.log('   ✅ Script location independence test completed');
         return true;
     }
@@ -198,13 +158,30 @@ async function testScriptLocationIndependence() {
         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 });
+        // Enhanced cleanup with retry logic
+        const cleanup = async (retries = 3) => {
+            for (let i = 0; i < retries; i++) {
+                try {
+                    if (fs_1.default.existsSync(tempProjectDir)) {
+                        fs_1.default.rmSync(tempProjectDir, { recursive: true, force: true });
+                    }
+                    if (fs_1.default.existsSync(userFraimDir)) {
+                        fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+                    }
+                    break; // Success
+                }
+                catch (e) {
+                    if (i === retries - 1) {
+                        console.warn('   ⚠️ Cleanup failed after retries:', e);
+                    }
+                    else {
+                        // Wait a bit before retry
+                        await new Promise(resolve => setTimeout(resolve, 100));
+                    }
+                }
             }
-        }
-        catch (e) { }
+        };
+        await cleanup();
     }
 }
 async function runScriptLocationTest(testCase) {

package/dist/tests/test-server-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerScriptPath = getServerScriptPath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Utility function to get the correct server script path
+ * Handles different execution contexts (running from project root, tests directory, etc.)
+ */
+function getServerScriptPath() {
+    // Try to find the server script from various possible locations
+    const possiblePaths = [
+        path_1.default.resolve(__dirname, '../dist/src/fraim-mcp-server.js'),
+        path_1.default.resolve(process.cwd(), 'dist/src/fraim-mcp-server.js'),
+        path_1.default.resolve(__dirname, '../../dist/src/fraim-mcp-server.js'),
+        path_1.default.resolve(__dirname, '../../../dist/src/fraim-mcp-server.js')
+    ];
+    for (const scriptPath of possiblePaths) {
+        if (fs_1.default.existsSync(scriptPath)) {
+            console.log(`   📍 Found server script at: ${scriptPath}`);
+            return scriptPath;
+        }
+    }
+    // If none found, log all attempted paths and use the first one
+    console.warn('   ⚠️ Server script not found at any of these paths:');
+    possiblePaths.forEach(p => console.warn(`      ${p}`));
+    console.warn('   Using first path (may fail)...');
+    return possiblePaths[0];
+}

package/dist/tests/test-session-rehydration.js

@@ -9,7 +9,7 @@ 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"));
+const test_server_utils_1 = require("./test-server-utils");
 async function testRehydrationAndExemptions() {
     console.log('   🚀 Testing Session Re-hydration and Initialization Exemptions...');
     let fraimProcess;
@@ -21,7 +21,7 @@ async function testRehydrationAndExemptions() {
     const startServer = async () => {
         console.log(`   Starting server on port ${PORT}...`);
         const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        const serverScript = path_1.default.resolve(__dirname, '../dist/src/fraim-mcp-server.js');
+        const serverScript = (0, test_server_utils_1.getServerScriptPath)();
         const proc = (0, node_child_process_1.spawn)(npxCommand, ['node', `"${serverScript}"`], {
             env: {
                 ...process.env,

package/dist/tests/test-setup-integration.js

@@ -0,0 +1,98 @@
+"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"));
+const os_1 = __importDefault(require("os"));
+const ide_detector_1 = require("../src/cli/setup/ide-detector");
+const mcp_config_generator_1 = require("../src/cli/setup/mcp-config-generator");
+const token_validator_1 = require("../src/cli/setup/token-validator");
+(0, node_test_1.test)('Setup integration - token validation flow', async () => {
+    // Test valid tokens
+    const validFraimKey = 'fraim_test123456789012345';
+    const validGithubToken = 'ghp_test123456789012345';
+    (0, node_assert_1.default)((0, token_validator_1.isValidTokenFormat)(validFraimKey, 'fraim'), 'Valid FRAIM key format should pass');
+    (0, node_assert_1.default)((0, token_validator_1.isValidTokenFormat)(validGithubToken, 'github'), 'Valid GitHub token format should pass');
+    (0, node_assert_1.default)(await (0, token_validator_1.validateFraimKey)(validFraimKey), 'Valid FRAIM key should validate');
+    // Test invalid tokens
+    (0, node_assert_1.default)(!(0, token_validator_1.isValidTokenFormat)('invalid_key', 'fraim'), 'Invalid FRAIM key should fail');
+    (0, node_assert_1.default)(!(0, token_validator_1.isValidTokenFormat)('invalid_token', 'github'), 'Invalid GitHub token should fail');
+    (0, node_assert_1.default)(!await (0, token_validator_1.validateFraimKey)('invalid_key'), 'Invalid FRAIM key should not validate');
+});
+(0, node_test_1.test)('Setup integration - MCP config generation for all IDE types', () => {
+    const testFraimKey = 'fraim_test123456789012345';
+    const testGithubToken = 'ghp_test123456789012345';
+    // Test all config types
+    const standardConfig = (0, mcp_config_generator_1.generateMCPConfig)('standard', testFraimKey, testGithubToken);
+    const kiroConfig = (0, mcp_config_generator_1.generateMCPConfig)('kiro', testFraimKey, testGithubToken);
+    const codexConfig = (0, mcp_config_generator_1.generateMCPConfig)('codex', testFraimKey, testGithubToken);
+    const windsurfConfig = (0, mcp_config_generator_1.generateMCPConfig)('windsurf', testFraimKey, testGithubToken);
+    // Verify standard config structure
+    (0, node_assert_1.default)(standardConfig.mcpServers, 'Standard config should have mcpServers');
+    (0, node_assert_1.default)(standardConfig.mcpServers.fraim.serverUrl, 'Standard should use serverUrl');
+    (0, node_assert_1.default)(standardConfig.mcpServers.fraim.headers['x-api-key'] === testFraimKey, 'Should contain FRAIM key');
+    // Verify kiro config structure
+    (0, node_assert_1.default)(kiroConfig.mcpServers.fraim.url, 'Kiro should use url');
+    (0, node_assert_1.default)(!kiroConfig.mcpServers.fraim.serverUrl, 'Kiro should not have serverUrl');
+    // Verify codex config is TOML string
+    (0, node_assert_1.default)(typeof codexConfig === 'string', 'Codex should return TOML string');
+    (0, node_assert_1.default)(codexConfig.includes('[mcp_servers.fraim]'), 'Should contain FRAIM section');
+    (0, node_assert_1.default)(codexConfig.includes(testFraimKey), 'Should contain FRAIM key');
+    // Verify windsurf config structure
+    (0, node_assert_1.default)(windsurfConfig.mcpServers.fraim.command, 'Windsurf should use command');
+    (0, node_assert_1.default)(windsurfConfig.mcpServers.fraim.env.FRAIM_API_KEY === testFraimKey, 'Should contain FRAIM key in env');
+});
+(0, node_test_1.test)('Setup integration - IDE detection works', () => {
+    const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    // Should return an array (might be empty in test environment)
+    (0, node_assert_1.default)(Array.isArray(detectedIDEs), 'Should return an array');
+    // If any IDEs are detected, they should have the correct structure
+    detectedIDEs.forEach(ide => {
+        (0, node_assert_1.default)(typeof ide.name === 'string', 'IDE should have name');
+        (0, node_assert_1.default)(typeof ide.configPath === 'string', 'IDE should have configPath');
+        (0, node_assert_1.default)(['json', 'toml'].includes(ide.configFormat), 'IDE should have valid configFormat');
+        (0, node_assert_1.default)(['standard', 'kiro', 'codex', 'windsurf'].includes(ide.configType), 'IDE should have valid configType');
+        (0, node_assert_1.default)(typeof ide.detectMethod === 'function', 'IDE should have detectMethod');
+    });
+});
+(0, node_test_1.test)('Setup integration - global config directory creation', () => {
+    const testConfigDir = path_1.default.join(os_1.default.tmpdir(), 'fraim-test-' + Date.now());
+    // Simulate creating global config directory
+    if (!fs_1.default.existsSync(testConfigDir)) {
+        fs_1.default.mkdirSync(testConfigDir, { recursive: true });
+    }
+    (0, node_assert_1.default)(fs_1.default.existsSync(testConfigDir), 'Config directory should be created');
+    // Test config file creation
+    const testConfig = {
+        version: '2.0.37',
+        apiKey: 'fraim_test123456789012345',
+        configuredAt: new Date().toISOString()
+    };
+    const configPath = path_1.default.join(testConfigDir, 'config.json');
+    fs_1.default.writeFileSync(configPath, JSON.stringify(testConfig, null, 2));
+    (0, node_assert_1.default)(fs_1.default.existsSync(configPath), 'Config file should be created');
+    const savedConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+    (0, node_assert_1.default)(savedConfig.apiKey === testConfig.apiKey, 'Config should contain API key');
+    (0, node_assert_1.default)(savedConfig.version === testConfig.version, 'Config should contain version');
+    // Cleanup
+    fs_1.default.rmSync(testConfigDir, { recursive: true, force: true });
+});
+(0, node_test_1.test)('Setup integration - backup functionality', () => {
+    const testDir = path_1.default.join(os_1.default.tmpdir(), 'fraim-backup-test-' + Date.now());
+    fs_1.default.mkdirSync(testDir, { recursive: true });
+    const originalConfigPath = path_1.default.join(testDir, 'test-config.json');
+    const originalConfig = { existing: 'config' };
+    fs_1.default.writeFileSync(originalConfigPath, JSON.stringify(originalConfig, null, 2));
+    // Simulate backup creation
+    const backupPath = `${originalConfigPath}.fraim-backup-${Date.now()}`;
+    fs_1.default.copyFileSync(originalConfigPath, backupPath);
+    (0, node_assert_1.default)(fs_1.default.existsSync(backupPath), 'Backup file should be created');
+    const backupConfig = JSON.parse(fs_1.default.readFileSync(backupPath, 'utf8'));
+    node_assert_1.default.deepStrictEqual(backupConfig, originalConfig, 'Backup should match original');
+    // Cleanup
+    fs_1.default.rmSync(testDir, { recursive: true, force: true });
+});

package/dist/tests/test-standalone.js

@@ -9,7 +9,7 @@ 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"));
+const test_server_utils_1 = require("./test-server-utils");
 async function testServerStartsAndResponds() {
     console.log('   🚀 Testing Fraim Standalone Server...');
     let fraimProcess;
@@ -35,7 +35,7 @@ async function testServerStartsAndResponds() {
         // 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, '../dist/src/fraim-mcp-server.js');
+        const serverScript = (0, test_server_utils_1.getServerScriptPath)();
         fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['node', `"${serverScript}"`], {
             env: {
                 ...process.env,

package/dist/tests/test-stub-registry.js

@@ -0,0 +1,136 @@
+#!/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"));
+const build_stub_registry_1 = require("../scripts/build-stub-registry");
+/**
+ * Tests for stub registry build process
+ * Ensures that the npm package contains only stubs and scripts, not full workflows
+ */
+// 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 build generates correct structure', async () => {
+    // Clean up any existing stubs
+    const projectRoot = findProjectRoot();
+    const stubsPath = path_1.default.join(projectRoot, 'registry', 'stubs');
+    if (fs_1.default.existsSync(stubsPath)) {
+        fs_1.default.rmSync(stubsPath, { recursive: true, force: true });
+    }
+    // Build stub registry
+    await (0, build_stub_registry_1.buildStubRegistry)();
+    // Verify stubs directory exists
+    (0, node_assert_1.default)(fs_1.default.existsSync(stubsPath), 'Stubs directory should exist');
+    // Verify workflows stubs directory exists
+    const workflowsStubsPath = path_1.default.join(stubsPath, 'workflows');
+    (0, node_assert_1.default)(fs_1.default.existsSync(workflowsStubsPath), 'Workflows stubs directory should exist');
+    // Verify at least some stubs were generated
+    const stubFiles = getAllFiles(workflowsStubsPath, '.md');
+    (0, node_assert_1.default)(stubFiles.length > 0, 'Should generate at least one workflow stub');
+    console.log(`✅ Generated ${stubFiles.length} workflow stubs`);
+});
+(0, node_test_1.test)('Generated stubs are lightweight and contain correct format', async () => {
+    const projectRoot = findProjectRoot();
+    const stubsPath = path_1.default.join(projectRoot, 'registry', 'stubs', 'workflows');
+    // Find a stub file to test
+    const stubFiles = getAllFiles(stubsPath, '.md');
+    (0, node_assert_1.default)(stubFiles.length > 0, 'Should have stub files to test');
+    const testStubPath = stubFiles[0];
+    const stubContent = fs_1.default.readFileSync(testStubPath, 'utf8');
+    // Verify stub format
+    (0, node_assert_1.default)(stubContent.includes('# FRAIM Workflow:'), 'Stub should have workflow title');
+    (0, node_assert_1.default)(stubContent.includes('FRAIM-managed workflow stub'), 'Stub should identify itself as a stub');
+    (0, node_assert_1.default)(stubContent.includes('get_fraim_workflow('), 'Stub should contain MCP call instruction');
+    (0, node_assert_1.default)(stubContent.includes('## Intent'), 'Stub should contain intent section');
+    (0, node_assert_1.default)(stubContent.includes('DO NOT EXECUTE'), 'Stub should contain execution warning');
+    // Verify stub is lightweight (should be much smaller than full workflow)
+    const stubLines = stubContent.split('\n').length;
+    (0, node_assert_1.default)(stubLines < 20, `Stub should be lightweight (${stubLines} lines), not a full workflow`);
+    console.log(`✅ Stub format verified (${stubLines} lines)`);
+});
+(0, node_test_1.test)('Stubs do not contain full workflow content', async () => {
+    const projectRoot = findProjectRoot();
+    const stubsPath = path_1.default.join(projectRoot, 'registry', 'stubs', 'workflows');
+    const fullWorkflowsPath = path_1.default.join(projectRoot, 'registry', 'workflows');
+    const stubFiles = getAllFiles(stubsPath, '.md');
+    (0, node_assert_1.default)(stubFiles.length > 0, 'Should have stub files to test');
+    for (const stubFile of stubFiles.slice(0, 3)) { // Test first 3 stubs
+        const stubContent = fs_1.default.readFileSync(stubFile, 'utf8');
+        // Find corresponding full workflow
+        const relativePath = path_1.default.relative(stubsPath, stubFile);
+        const fullWorkflowPath = path_1.default.join(fullWorkflowsPath, relativePath);
+        if (fs_1.default.existsSync(fullWorkflowPath)) {
+            const fullContent = fs_1.default.readFileSync(fullWorkflowPath, 'utf8');
+            // Stub should be much smaller than full workflow
+            (0, node_assert_1.default)(stubContent.length < fullContent.length * 0.5, `Stub should be <50% size of full workflow (stub: ${stubContent.length}, full: ${fullContent.length})`);
+            // More importantly, stub should not contain full workflow sections
+            (0, node_assert_1.default)(!stubContent.includes('## WORKFLOW TRIGGER'), 'Stub should not contain WORKFLOW TRIGGER section');
+            (0, node_assert_1.default)(!stubContent.includes('## AI AGENT PROCESS'), 'Stub should not contain AI AGENT PROCESS section');
+            (0, node_assert_1.default)(!stubContent.includes('## EXAMPLES'), 'Stub should not contain EXAMPLES section');
+        }
+    }
+    console.log('✅ Stubs are properly lightweight');
+});
+(0, node_test_1.test)('Package.json files array excludes full workflows', () => {
+    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 || [];
+    // Should include stubs
+    (0, node_assert_1.default)(files.includes('registry/stubs/'), 'Should include registry/stubs/');
+    // Should include scripts
+    (0, node_assert_1.default)(files.includes('registry/scripts/'), 'Should include registry/scripts/');
+    // Should NOT include full registry
+    (0, node_assert_1.default)(!files.includes('registry/'), 'Should NOT include full registry/');
+    (0, node_assert_1.default)(!files.includes('registry/workflows/'), 'Should NOT include registry/workflows/');
+    (0, node_assert_1.default)(!files.includes('registry/templates/'), 'Should NOT include registry/templates/');
+    (0, node_assert_1.default)(!files.includes('registry/rules/'), 'Should NOT include registry/rules/');
+    console.log('✅ Package.json correctly excludes full workflows');
+});
+(0, node_test_1.test)('Scripts are still included in package', () => {
+    const projectRoot = findProjectRoot();
+    const scriptsPath = path_1.default.join(projectRoot, 'registry', 'scripts');
+    (0, node_assert_1.default)(fs_1.default.existsSync(scriptsPath), 'Scripts directory should exist');
+    const scriptFiles = getAllFiles(scriptsPath);
+    (0, node_assert_1.default)(scriptFiles.length > 0, 'Should have script files');
+    // Verify package.json includes scripts
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+    const files = packageJson.files || [];
+    (0, node_assert_1.default)(files.includes('registry/scripts/'), 'Package should include scripts');
+    console.log(`✅ ${scriptFiles.length} scripts are included in package`);
+});
+// Helper function to get all files recursively
+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-sync-stubs.js

@@ -0,0 +1,143 @@
+#!/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"));
+const os_1 = __importDefault(require("os"));
+const sync_1 = require("../src/cli/commands/sync");
+/**
+ * Tests for sync command with stub registry
+ * Ensures sync works correctly with pre-generated stubs
+ */
+// Use a temporary directory for testing
+const TEST_PROJECT_DIR = path_1.default.join(os_1.default.tmpdir(), 'fraim-test-sync-' + Date.now());
+const TEST_FRAIM_DIR = path_1.default.join(TEST_PROJECT_DIR, '.fraim');
+const TEST_WORKFLOWS_DIR = path_1.default.join(TEST_FRAIM_DIR, 'workflows');
+(0, node_test_1.test)('Sync command works with stub registry', async () => {
+    // Setup test environment
+    setupTestProject();
+    // Change to test directory
+    const originalCwd = process.cwd();
+    process.chdir(TEST_PROJECT_DIR);
+    try {
+        // Run sync
+        await (0, sync_1.runSync)({ force: true });
+        // Verify workflows directory was created
+        (0, node_assert_1.default)(fs_1.default.existsSync(TEST_WORKFLOWS_DIR), 'Workflows directory should be created');
+        // Verify stubs were copied
+        const stubFiles = getAllFiles(TEST_WORKFLOWS_DIR, '.md');
+        (0, node_assert_1.default)(stubFiles.length > 0, 'Should copy workflow stubs');
+        // Verify stubs have correct format
+        const testStub = fs_1.default.readFileSync(stubFiles[0], 'utf8');
+        (0, node_assert_1.default)(testStub.includes('FRAIM-managed workflow stub'), 'Copied files should be stubs');
+        (0, node_assert_1.default)(testStub.includes('get_fraim_workflow('), 'Stubs should contain MCP call instruction');
+        console.log(`✅ Sync copied ${stubFiles.length} workflow stubs`);
+    }
+    finally {
+        // Restore original directory
+        process.chdir(originalCwd);
+        // Cleanup test directory
+        if (fs_1.default.existsSync(TEST_PROJECT_DIR)) {
+            fs_1.default.rmSync(TEST_PROJECT_DIR, { recursive: true, force: true });
+        }
+    }
+});
+(0, node_test_1.test)('Sync uses stub registry, not full workflows', async () => {
+    // Setup test environment
+    setupTestProject();
+    const originalCwd = process.cwd();
+    process.chdir(TEST_PROJECT_DIR);
+    try {
+        // Run sync
+        await (0, sync_1.runSync)({ force: true });
+        // Verify synced files are stubs, not full workflows
+        const stubFiles = getAllFiles(TEST_WORKFLOWS_DIR, '.md');
+        (0, node_assert_1.default)(stubFiles.length > 0, 'Should have synced files');
+        for (const stubFile of stubFiles.slice(0, 3)) { // Test first 3 files
+            const content = fs_1.default.readFileSync(stubFile, 'utf8');
+            const lines = content.split('\n').length;
+            // Should be lightweight stubs
+            (0, node_assert_1.default)(lines < 20, `File should be a stub (${lines} lines), not a full workflow`);
+            (0, node_assert_1.default)(content.includes('DO NOT EXECUTE'), 'Should contain stub warning');
+            (0, node_assert_1.default)(!content.includes('## WORKFLOW TRIGGER'), 'Should not contain full workflow sections');
+            (0, node_assert_1.default)(!content.includes('## AI AGENT PROCESS'), 'Should not contain full workflow sections');
+        }
+        console.log('✅ Sync correctly uses stubs, not full workflows');
+    }
+    finally {
+        process.chdir(originalCwd);
+        if (fs_1.default.existsSync(TEST_PROJECT_DIR)) {
+            fs_1.default.rmSync(TEST_PROJECT_DIR, { recursive: true, force: true });
+        }
+    }
+});
+(0, node_test_1.test)('Sync preserves directory structure from stub registry', async () => {
+    setupTestProject();
+    const originalCwd = process.cwd();
+    process.chdir(TEST_PROJECT_DIR);
+    try {
+        await (0, sync_1.runSync)({ force: true });
+        // Verify directory structure is preserved
+        const expectedDirs = [
+            'bootstrap',
+            'product-building',
+            'customer-development',
+            'marketing'
+        ];
+        for (const expectedDir of expectedDirs) {
+            const dirPath = path_1.default.join(TEST_WORKFLOWS_DIR, expectedDir);
+            if (fs_1.default.existsSync(dirPath)) {
+                (0, node_assert_1.default)(fs_1.default.statSync(dirPath).isDirectory(), `${expectedDir} should be a directory`);
+                // Should contain stub files
+                const files = fs_1.default.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+                (0, node_assert_1.default)(files.length > 0, `${expectedDir} should contain workflow stubs`);
+            }
+        }
+        console.log('✅ Directory structure preserved correctly');
+    }
+    finally {
+        process.chdir(originalCwd);
+        if (fs_1.default.existsSync(TEST_PROJECT_DIR)) {
+            fs_1.default.rmSync(TEST_PROJECT_DIR, { recursive: true, force: true });
+        }
+    }
+});
+function setupTestProject() {
+    // Create test project directory
+    if (fs_1.default.existsSync(TEST_PROJECT_DIR)) {
+        fs_1.default.rmSync(TEST_PROJECT_DIR, { recursive: true, force: true });
+    }
+    fs_1.default.mkdirSync(TEST_PROJECT_DIR, { recursive: true });
+    // Create .fraim directory
+    fs_1.default.mkdirSync(TEST_FRAIM_DIR, { recursive: true });
+    // Create basic config.json
+    const config = {
+        version: "2.0.36",
+        customizations: {}
+    };
+    fs_1.default.writeFileSync(path_1.default.join(TEST_FRAIM_DIR, 'config.json'), JSON.stringify(config, null, 2));
+}
+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-telemetry.js

@@ -9,7 +9,7 @@ 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"));
+const test_server_utils_1 = require("./test-server-utils");
 async function testTelemetryFlow() {
     console.log('   🚀 Testing Fraim Telemetry System...');
     let fraimProcess;
@@ -39,7 +39,7 @@ async function testTelemetryFlow() {
         // 2. Start Server
         console.log(`   Starting server on port ${PORT}...`);
         const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        const serverScript = path_1.default.resolve(__dirname, '../dist/src/fraim-mcp-server.js');
+        const serverScript = (0, test_server_utils_1.getServerScriptPath)();
         fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['node', `"${serverScript}"`], {
             env: {
                 ...process.env,