fraim-framework 2.0.35 → 2.0.37

package/dist/tests/test-client-scripts-validation.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = require("./test-utils");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const node_assert_1 = __importDefault(require("node:assert"));
+async function testNoFraimInternalImports() {
+    console.log('   🧪 Testing registry scripts do not import FRAIM internals...');
+    try {
+        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const scriptFiles = ['cleanup-branch.ts', 'generate-engagement-emails.ts', 'newsletter-helpers.ts'];
+        for (const scriptFile of scriptFiles) {
+            const scriptPath = (0, path_1.join)(scriptsDir, scriptFile);
+            if ((0, fs_1.existsSync)(scriptPath)) {
+                const content = (0, fs_1.readFileSync)(scriptPath, 'utf-8');
+                // Should not import from ../../src/
+                (0, node_assert_1.default)(!content.includes('../../src/'), `${scriptFile} should not import from ../../src/`);
+                // Should not import fraim-config
+                (0, node_assert_1.default)(!content.includes('./fraim-config'), `${scriptFile} should not import fraim-config`);
+                // Should have self-contained config loading
+                (0, node_assert_1.default)(content.includes('.fraim/config.json') || content.includes('loadClientConfig'), `${scriptFile} should read config directly`);
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        console.error('   ❌ FRAIM internal imports check failed:', e);
+        return false;
+    }
+}
+async function testInlineUtilityFunctions() {
+    console.log('   🧪 Testing scripts have inline utility functions...');
+    try {
+        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const scriptPath = (0, path_1.join)(scriptsDir, 'cleanup-branch.ts');
+        if ((0, fs_1.existsSync)(scriptPath)) {
+            const content = (0, fs_1.readFileSync)(scriptPath, 'utf-8');
+            // Should have inline extractIssueNumber function
+            (0, node_assert_1.default)(content.includes('function extractIssueNumber'), 'cleanup-branch.ts should have inline extractIssueNumber function');
+            // Should have inline getCurrentGitBranch function
+            (0, node_assert_1.default)(content.includes('function getCurrentGitBranch'), 'cleanup-branch.ts should have inline getCurrentGitBranch function');
+        }
+        return true;
+    }
+    catch (e) {
+        console.error('   ❌ Inline utility functions check failed:', e);
+        return false;
+    }
+}
+async function testConfigLoadingFromJson() {
+    console.log('   🧪 Testing scripts load config from .fraim/config.json...');
+    try {
+        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const scriptPath = (0, path_1.join)(scriptsDir, 'generate-engagement-emails.ts');
+        if ((0, fs_1.existsSync)(scriptPath)) {
+            const content = (0, fs_1.readFileSync)(scriptPath, 'utf-8');
+            // Should have loadClientConfig function
+            (0, node_assert_1.default)(content.includes('function loadClientConfig'), 'generate-engagement-emails.ts should have loadClientConfig function');
+            // Should read .fraim/config.json
+            (0, node_assert_1.default)(content.includes('.fraim/config.json'), 'generate-engagement-emails.ts should read .fraim/config.json');
+        }
+        return true;
+    }
+    catch (e) {
+        console.error('   ❌ Config loading check failed:', e);
+        return false;
+    }
+}
+async function testRegistryPathValidator() {
+    console.log('   🧪 Testing registry path validator passes...');
+    try {
+        (0, child_process_1.execSync)('npm run validate:registry', { stdio: 'pipe' });
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Registry validation failed:', error.message);
+        return false;
+    }
+}
+async function testScriptExecutability() {
+    console.log('   🧪 Testing scripts are executable without import errors...');
+    try {
+        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const scriptPath = (0, path_1.join)(scriptsDir, 'cleanup-branch.ts');
+        if ((0, fs_1.existsSync)(scriptPath)) {
+            // Test that the script can be parsed without import errors
+            const result = (0, child_process_1.execSync)(`npx tsx ${scriptPath} --help`, {
+                stdio: 'pipe',
+                encoding: 'utf-8'
+            });
+            // Should show help without errors
+            (0, node_assert_1.default)(result.includes('Branch Cleanup Script'), 'cleanup-branch.ts should show help without import errors');
+        }
+        return true;
+    }
+    catch (error) {
+        // Check if it's an import error
+        if (error.message.includes('Cannot find module') || error.message.includes('../../src/')) {
+            console.error('   ❌ Script has import errors:', error.message);
+            return false;
+        }
+        // Other errors (like missing git repo) are acceptable for this test
+        return true;
+    }
+}
+const testCases = [
+    {
+        name: 'Registry scripts should not import FRAIM internals',
+        testFunction: testNoFraimInternalImports
+    },
+    {
+        name: 'Scripts should have inline utility functions',
+        testFunction: testInlineUtilityFunctions
+    },
+    {
+        name: 'Scripts should load config from .fraim/config.json',
+        testFunction: testConfigLoadingFromJson
+    },
+    {
+        name: 'Registry path validator should pass',
+        testFunction: testRegistryPathValidator
+    },
+    {
+        name: 'Scripts should be executable without import errors',
+        testFunction: testScriptExecutability
+    }
+];
+// Run the tests using the standard test runner
+(0, test_utils_1.runTests)(testCases, async (testCase) => testCase.testFunction(), 'Client-Side Script Validation');

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

@@ -0,0 +1,88 @@
+#!/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
+ */
+(0, node_test_1.test)('Stub registry is significantly smaller than full registry', () => {
+    const fullWorkflowsPath = path_1.default.join(__dirname, '..', 'registry', 'workflows');
+    const stubWorkflowsPath = path_1.default.join(__dirname, '..', '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 packageJsonPath = path_1.default.join(__dirname, '..', '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(__dirname, '..', 'registry', 'workflows'));
+    const templatesSize = getDirectorySize(path_1.default.join(__dirname, '..', 'registry', 'templates'));
+    const rulesSize = getDirectorySize(path_1.default.join(__dirname, '..', 'registry', 'rules'));
+    const excludedSize = fullWorkflowsSize + templatesSize + rulesSize;
+    // What's included
+    const stubsSize = getDirectorySize(path_1.default.join(__dirname, '..', 'registry', 'stubs'));
+    const scriptsSize = getDirectorySize(path_1.default.join(__dirname, '..', '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-script-location-independence.js

@@ -89,24 +89,47 @@ async function testScriptLocationIndependence() {
         if (fs_1.default.existsSync(prepIssueScript)) {
             try {
                 const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-                // Use Git Bash on Windows, regular bash on Unix
-                const bashCommand = process.platform === 'win32'
-                    ? `"C:\\Program Files\\Git\\bin\\bash.exe" "${prepIssueScript}" --help`
-                    : `"${prepIssueScript}" --help`;
-                const output = execSync(bashCommand, {
-                    cwd: tempProjectDir,
-                    encoding: 'utf-8',
-                    timeout: 10000
-                });
+                // On Windows, we need to check if Git Bash is available
+                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 bash script tests');
+                        console.log('   ✅ Script location independence test completed (Windows limitation)');
+                        return true;
+                    }
+                    const bashCommand = `"${bashPath}" "${prepIssueScript}" --help`;
+                    const output = execSync(bashCommand, {
+                        cwd: tempProjectDir,
+                        encoding: 'utf-8',
+                        timeout: 10000
+                    });
+                }
+                else {
+                    // Unix systems
+                    const output = execSync(`"${prepIssueScript}" --help`, {
+                        cwd: tempProjectDir,
+                        encoding: 'utf-8',
+                        timeout: 10000
+                    });
+                }
                 // If we get here, the script at least started successfully
                 console.log('   ✅ prep-issue.sh executed successfully from user directory');
             }
             catch (error) {
                 // The script may fail due to missing repo, but as long as it started, that's OK
-                if (process.platform === 'win32' && error.message.includes('not recognized')) {
-                    console.log('   ⚠️ Git Bash not found on Windows, skipping prep-issue test');
-                }
-                else if (error.message.includes('Repository not found') || error.message.includes('fatal: repository')) {
+                if (error.message.includes('Repository not found') ||
+                    error.message.includes('fatal: repository') ||
+                    error.message.includes('not a git repository')) {
                     // This is expected - the test repo doesn't exist, but the script ran
                     console.log('   ✅ prep-issue.sh executed from user directory (repo not found is expected)');
                 }
@@ -116,31 +139,56 @@ 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')));
-                const bashCommand = process.platform === 'win32'
-                    ? `"C:\\Program Files\\Git\\bin\\bash.exe" "${qualityCheckScript}" --help`
-                    : `"${qualityCheckScript}" --help`;
-                const output = execSync(bashCommand, {
-                    cwd: tempProjectDir,
-                    encoding: 'utf-8',
-                    timeout: 10000
-                });
-                console.log('   ✅ code-quality-check.sh executed successfully from user directory');
-            }
-            catch (error) {
-                if (process.platform === 'win32' && error.message.includes('not recognized')) {
-                    console.log('   ⚠️ Git Bash not found on Windows, skipping quality check test');
+                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 {
-                    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
+                    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');
         }
         console.log('   ✅ Script location independence test completed');
         return true;

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

@@ -0,0 +1,120 @@
+#!/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
+ */
+(0, node_test_1.test)('Stub registry build generates correct structure', async () => {
+    // Clean up any existing stubs
+    const stubsPath = path_1.default.join(__dirname, '..', '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 stubsPath = path_1.default.join(__dirname, '..', '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 stubsPath = path_1.default.join(__dirname, '..', 'registry', 'stubs', 'workflows');
+    const fullWorkflowsPath = path_1.default.join(__dirname, '..', '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 packageJsonPath = path_1.default.join(__dirname, '..', '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 scriptsPath = path_1.default.join(__dirname, '..', '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(__dirname, '..', '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;
+}