fraim-framework 2.0.26 → 2.0.30

package/dist/tests/test-chalk-resolution-issue.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Test to reproduce and verify the fix for the chalk v5 resolution issue
+ *
+ * This test creates a scenario where npm might resolve chalk to v5 by:
+ * 1. Creating a dependency that requires chalk v5
+ * 2. Testing if fraim-framework with ^4.1.2 gets upgraded
+ * 3. Testing if fraim-framework with 4.1.2 (pinned) stays at v4
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function runCommand(command, args, cwd) {
+    return new Promise((resolve) => {
+        const proc = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: 'pipe',
+            shell: true
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+async function testChalkResolutionWithConflict() {
+    console.log('   🧪 Testing chalk resolution with conflicting dependency...');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'chalk-conflict-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        // 1. Create a package that depends on chalk v5
+        console.log('   📦 Creating fake package that requires chalk v5...');
+        const fakePackageDir = path_1.default.join(tempDir, 'fake-chalk5-package');
+        fs_1.default.mkdirSync(fakePackageDir, { recursive: true });
+        const fakePackageJson = {
+            name: 'fake-chalk5-package',
+            version: '1.0.0',
+            dependencies: {
+                'chalk': '^5.0.0'
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(fakePackageDir, 'package.json'), JSON.stringify(fakePackageJson, null, 2));
+        // Create a simple index.js that uses chalk
+        fs_1.default.writeFileSync(path_1.default.join(fakePackageDir, 'index.js'), 'export { default as chalk } from "chalk";\n');
+        // 2. Pack fraim-framework with ^4.1.2 (unpinned)
+        console.log('   📦 Packing fraim-framework with ^4.1.2...');
+        const projectRoot = process.cwd();
+        const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+        const originalPackageJson = fs_1.default.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(originalPackageJson);
+        // Temporarily change to ^4.1.2
+        packageJson.dependencies.chalk = '^4.1.2';
+        fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        const packResult = (0, node_child_process_1.execSync)('npm pack', {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        const tarballName = packResult.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            fs_1.default.writeFileSync(packageJsonPath, originalPackageJson);
+            return false;
+        }
+        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        // Restore original package.json
+        fs_1.default.writeFileSync(packageJsonPath, originalPackageJson);
+        // 3. Create test project that depends on BOTH packages
+        console.log('   🔧 Creating test project with conflicting dependencies...');
+        const testPackageJson = {
+            name: 'chalk-conflict-test',
+            version: '1.0.0',
+            dependencies: {
+                'fake-chalk5-package': 'file:./fake-chalk5-package',
+                'fraim-framework': `file:${tarballPath}`
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(testPackageJson, null, 2));
+        // 4. Install dependencies - npm will try to resolve chalk
+        console.log('   📥 Installing with conflicting chalk requirements...');
+        console.log('   ⚠️  fake-chalk5-package wants chalk ^5.0.0');
+        console.log('   ⚠️  fraim-framework wants chalk ^4.1.2');
+        const installResult = await runCommand('npm', ['install'], tempDir);
+        if (installResult.code !== 0) {
+            console.log('   ⚠️  npm install failed (might be expected)');
+            console.log(`   stderr: ${installResult.stderr.substring(0, 300)}`);
+        }
+        // 5. Check what version of chalk was installed for fraim-framework
+        const fraimChalkPath = path_1.default.join(tempDir, 'node_modules', 'fraim-framework', 'node_modules', 'chalk', 'package.json');
+        const rootChalkPath = path_1.default.join(tempDir, 'node_modules', 'chalk', 'package.json');
+        let fraimChalkVersion = null;
+        let rootChalkVersion = null;
+        if (fs_1.default.existsSync(fraimChalkPath)) {
+            const chalkPkg = JSON.parse(fs_1.default.readFileSync(fraimChalkPath, 'utf-8'));
+            fraimChalkVersion = chalkPkg.version;
+            console.log(`   📋 fraim-framework's chalk: ${fraimChalkVersion}`);
+        }
+        if (fs_1.default.existsSync(rootChalkPath)) {
+            const chalkPkg = JSON.parse(fs_1.default.readFileSync(rootChalkPath, 'utf-8'));
+            rootChalkVersion = chalkPkg.version;
+            console.log(`   📋 Root chalk: ${rootChalkVersion}`);
+        }
+        // 6. Try to load fraim CLI
+        console.log('   🚀 Testing if fraim CLI loads...');
+        const testScript = `
+try {
+    const fraimCli = require('./node_modules/fraim-framework/dist/src/cli/fraim.js');
+    console.log('SUCCESS: fraim CLI loaded');
+    process.exit(0);
+} catch (error) {
+    if (error.code === 'ERR_REQUIRE_ESM') {
+        console.log('ERROR: ERR_REQUIRE_ESM - chalk v5 was used!');
+        console.log('Chalk version caused issue:', error.message);
+        process.exit(1);
+    } else {
+        console.log('ERROR: Other error:', error.message);
+        process.exit(2);
+    }
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        const testResult = await runCommand('node', ['test.js'], tempDir);
+        if (testResult.code === 1) {
+            console.log('   ❌ REPRODUCED THE BUG! npm resolved chalk to v5');
+            console.log('   ❌ fraim-framework with ^4.1.2 got chalk v5 due to conflict');
+            console.log('   ✅ This proves the issue exists with ^4.1.2');
+            // Cleanup
+            fs_1.default.unlinkSync(tarballPath);
+            return true; // We successfully reproduced the bug!
+        }
+        else if (testResult.code === 0) {
+            console.log('   ℹ️  fraim CLI loaded successfully');
+            console.log('   ℹ️  npm resolved the conflict without upgrading to v5');
+            console.log('   ℹ️  This scenario didn\'t trigger the bug, but it could in other environments');
+        }
+        else {
+            console.log('   ⚠️  Got unexpected error');
+            console.log(`   stdout: ${testResult.stdout}`);
+        }
+        // Cleanup
+        fs_1.default.unlinkSync(tarballPath);
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed with error:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            console.log('   🧹 Cleaned up temp directory');
+        }
+        catch (e) {
+            console.log('   ⚠️  Could not clean up temp directory');
+        }
+    }
+}
+async function testChalkResolutionWithPinnedVersion() {
+    console.log('   🧪 Testing chalk resolution with PINNED version (4.1.2)...');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'chalk-pinned-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        // 1. Create a package that depends on chalk v5
+        console.log('   📦 Creating fake package that requires chalk v5...');
+        const fakePackageDir = path_1.default.join(tempDir, 'fake-chalk5-package');
+        fs_1.default.mkdirSync(fakePackageDir, { recursive: true });
+        const fakePackageJson = {
+            name: 'fake-chalk5-package',
+            version: '1.0.0',
+            dependencies: {
+                'chalk': '^5.0.0'
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(fakePackageDir, 'package.json'), JSON.stringify(fakePackageJson, null, 2));
+        fs_1.default.writeFileSync(path_1.default.join(fakePackageDir, 'index.js'), 'export { default as chalk } from "chalk";\n');
+        // 2. Pack fraim-framework with 4.1.2 (PINNED - current state)
+        console.log('   📦 Packing fraim-framework with pinned 4.1.2...');
+        const projectRoot = process.cwd();
+        const packResult = (0, node_child_process_1.execSync)('npm pack', {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        const tarballName = packResult.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            return false;
+        }
+        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        // 3. Create test project with conflicting dependencies
+        console.log('   🔧 Creating test project with conflicting dependencies...');
+        const testPackageJson = {
+            name: 'chalk-pinned-test',
+            version: '1.0.0',
+            dependencies: {
+                'fake-chalk5-package': 'file:./fake-chalk5-package',
+                'fraim-framework': `file:${tarballPath}`
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(testPackageJson, null, 2));
+        // 4. Install dependencies
+        console.log('   📥 Installing with conflicting chalk requirements...');
+        console.log('   ⚠️  fake-chalk5-package wants chalk ^5.0.0');
+        console.log('   ✅ fraim-framework wants chalk 4.1.2 (PINNED)');
+        const installResult = await runCommand('npm', ['install'], tempDir);
+        if (installResult.code !== 0) {
+            console.log('   ⚠️  npm install failed');
+        }
+        // 5. Check chalk versions
+        const fraimChalkPath = path_1.default.join(tempDir, 'node_modules', 'fraim-framework', 'node_modules', 'chalk', 'package.json');
+        const rootChalkPath = path_1.default.join(tempDir, 'node_modules', 'chalk', 'package.json');
+        let fraimChalkVersion = null;
+        let rootChalkVersion = null;
+        if (fs_1.default.existsSync(fraimChalkPath)) {
+            const chalkPkg = JSON.parse(fs_1.default.readFileSync(fraimChalkPath, 'utf-8'));
+            fraimChalkVersion = chalkPkg.version;
+            console.log(`   📋 fraim-framework's chalk: ${fraimChalkVersion}`);
+        }
+        if (fs_1.default.existsSync(rootChalkPath)) {
+            const chalkPkg = JSON.parse(fs_1.default.readFileSync(rootChalkPath, 'utf-8'));
+            rootChalkVersion = chalkPkg.version;
+            console.log(`   📋 Root chalk: ${rootChalkVersion}`);
+        }
+        // Verify fraim has v4
+        if (fraimChalkVersion && !fraimChalkVersion.startsWith('4.')) {
+            console.log(`   ❌ PINNED version failed! Got chalk ${fraimChalkVersion}`);
+            fs_1.default.unlinkSync(tarballPath);
+            return false;
+        }
+        // 6. Try to load fraim CLI
+        console.log('   🚀 Testing if fraim CLI loads...');
+        const testScript = `
+try {
+    const fraimCli = require('./node_modules/fraim-framework/dist/src/cli/fraim.js');
+    console.log('SUCCESS: fraim CLI loaded with pinned chalk');
+    process.exit(0);
+} catch (error) {
+    if (error.code === 'ERR_REQUIRE_ESM') {
+        console.log('ERROR: ERR_REQUIRE_ESM even with pinned version!');
+        process.exit(1);
+    } else {
+        console.log('ERROR: Other error:', error.message);
+        process.exit(2);
+    }
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        const testResult = await runCommand('node', ['test.js'], tempDir);
+        if (testResult.code === 0) {
+            console.log('   ✅ SUCCESS! Pinned version prevents chalk v5 upgrade');
+            console.log('   ✅ fraim CLI works even with chalk v5 dependency nearby');
+            console.log('   ✅ This proves the fix works!');
+        }
+        else if (testResult.code === 1) {
+            console.log('   ❌ FAILED! Even pinned version got chalk v5');
+            console.log('   ❌ The fix doesn\'t work!');
+            fs_1.default.unlinkSync(tarballPath);
+            return false;
+        }
+        // Cleanup
+        fs_1.default.unlinkSync(tarballPath);
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed with error:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            console.log('   🧹 Cleaned up temp directory');
+        }
+        catch (e) {
+            console.log('   ⚠️  Could not clean up temp directory');
+        }
+    }
+}
+async function runChalkResolutionTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Chalk Resolution with Conflict (^4.1.2)',
+        description: 'Tests if ^4.1.2 allows npm to upgrade to chalk v5 when there\'s a conflicting dependency',
+        testFunction: testChalkResolutionWithConflict,
+        tags: ['chalk', 'resolution', 'conflict']
+    },
+    {
+        name: 'Chalk Resolution with Pinned Version (4.1.2)',
+        description: 'Tests if pinned 4.1.2 prevents npm from upgrading to chalk v5',
+        testFunction: testChalkResolutionWithPinnedVersion,
+        tags: ['chalk', 'resolution', 'pinned', 'fix']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runChalkResolutionTest, 'Chalk Resolution Issue Test');

package/dist/tests/test-cli.js

@@ -110,8 +110,6 @@ async function testCliLifecycle() {
         }
         node_assert_1.default.ok(config.customizations, 'config.customizations should exist');
         node_assert_1.default.strictEqual(config.customizations.workflowsPath, '.fraim/workflows');
-        node_assert_1.default.ok(config.architecture, 'architecture should be in generated config');
-        node_assert_1.default.ok(config.testing, 'testing should be in generated config');
         node_assert_1.default.ok(!config.mcp, 'mcp should not be in generated config');
         // 2. Test `fraim sync`
         // We need a fake registry for sync to work against

package/dist/tests/test-fraim-install-chalk-issue.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Integration test to verify fraim-framework installs correctly
+ * and doesn't have the chalk ESM issue
+ *
+ * This test:
+ * 1. Packs the current fraim-framework into a tarball
+ * 2. Installs it fresh in a temp directory
+ * 3. Runs fraim init to verify it works
+ * 4. Tests with both pinned (4.1.2) and unpinned (^4.1.2) chalk versions
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const test_utils_1 = require("./test-utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function runCommand(command, args, cwd) {
+    return new Promise((resolve) => {
+        const proc = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: 'pipe',
+            shell: true
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+async function testFraimInstallWithPinnedChalk() {
+    console.log('   🧪 Testing FRAIM install with PINNED chalk (4.1.2)...');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-install-pinned-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        // 1. Pack the current fraim-framework
+        console.log('   📦 Packing fraim-framework...');
+        const projectRoot = process.cwd();
+        // Run npm pack in the project root
+        const packResult = (0, node_child_process_1.execSync)('npm pack', {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        const tarballName = packResult.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            console.log('   ❌ Failed to get tarball name');
+            return false;
+        }
+        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        console.log(`   ✅ Created tarball: ${tarballName}`);
+        // 2. Create a test project
+        const testPackageJson = {
+            name: 'fraim-install-test',
+            version: '1.0.0',
+            private: true
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(testPackageJson, null, 2));
+        // 3. Install fraim-framework from the tarball
+        console.log('   📥 Installing fraim-framework from tarball...');
+        const installResult = await runCommand('npm', ['install', tarballPath, '--silent'], tempDir);
+        if (installResult.code !== 0) {
+            console.log('   ❌ npm install failed');
+            console.log(`   stderr: ${installResult.stderr.substring(0, 500)}`);
+            return false;
+        }
+        console.log('   ✅ fraim-framework installed successfully');
+        // 4. Check which version of chalk was installed
+        const chalkPackageJsonPath = path_1.default.join(tempDir, 'node_modules', 'chalk', 'package.json');
+        if (!fs_1.default.existsSync(chalkPackageJsonPath)) {
+            console.log('   ❌ chalk not found in node_modules');
+            return false;
+        }
+        const chalkPackageJson = JSON.parse(fs_1.default.readFileSync(chalkPackageJsonPath, 'utf-8'));
+        console.log(`   📋 Installed chalk version: ${chalkPackageJson.version}`);
+        // Verify it's v4.x
+        if (!chalkPackageJson.version.startsWith('4.')) {
+            console.log(`   ❌ Expected chalk v4.x, got ${chalkPackageJson.version}`);
+            return false;
+        }
+        console.log('   ✅ Chalk v4 installed correctly');
+        // 5. Try to run fraim init (should work)
+        console.log('   🚀 Running fraim init...');
+        const fraimBin = path_1.default.join(tempDir, 'node_modules', '.bin', 'fraim');
+        // Create a simple test by requiring the CLI directly
+        const testScript = `
+const fraimCli = require('./node_modules/fraim-framework/dist/src/cli/fraim.js');
+console.log('✅ fraim CLI loaded successfully');
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        const testResult = await runCommand('node', ['test.js'], tempDir);
+        if (testResult.code !== 0) {
+            console.log('   ❌ Failed to load fraim CLI');
+            console.log(`   stderr: ${testResult.stderr.substring(0, 500)}`);
+            return false;
+        }
+        if (!testResult.stdout.includes('fraim CLI loaded successfully')) {
+            console.log('   ❌ fraim CLI did not load correctly');
+            return false;
+        }
+        console.log('   ✅ fraim CLI works with pinned chalk!');
+        // Cleanup tarball
+        fs_1.default.unlinkSync(tarballPath);
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed with error:', error);
+        return false;
+    }
+    finally {
+        // Cleanup
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            console.log('   🧹 Cleaned up temp directory');
+        }
+        catch (e) {
+            console.log('   ⚠️  Could not clean up temp directory');
+        }
+    }
+}
+async function testFraimInstallWithUnpinnedChalk() {
+    console.log('   🧪 Testing FRAIM install with UNPINNED chalk (^4.1.2)...');
+    console.log('   ⚠️  This simulates the original issue...');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-install-unpinned-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        // 1. Temporarily modify package.json to use ^4.1.2
+        const projectRoot = process.cwd();
+        const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+        const originalPackageJson = fs_1.default.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(originalPackageJson);
+        // Save original chalk version
+        const originalChalkVersion = packageJson.dependencies.chalk;
+        console.log(`   📋 Original chalk version: ${originalChalkVersion}`);
+        // Temporarily change to ^4.1.2
+        packageJson.dependencies.chalk = '^4.1.2';
+        fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log('   🔄 Temporarily changed chalk to ^4.1.2');
+        // 2. Pack with unpinned version
+        console.log('   📦 Packing fraim-framework with unpinned chalk...');
+        const packResult = (0, node_child_process_1.execSync)('npm pack', {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        const tarballName = packResult.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            console.log('   ❌ Failed to get tarball name');
+            // Restore original package.json
+            fs_1.default.writeFileSync(packageJsonPath, originalPackageJson);
+            return false;
+        }
+        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        console.log(`   ✅ Created tarball: ${tarballName}`);
+        // 3. Restore original package.json
+        fs_1.default.writeFileSync(packageJsonPath, originalPackageJson);
+        console.log('   ✅ Restored original package.json');
+        // 4. Create a test project
+        const testPackageJson = {
+            name: 'fraim-install-test-unpinned',
+            version: '1.0.0',
+            private: true
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(testPackageJson, null, 2));
+        // 5. Install fraim-framework from the tarball
+        console.log('   📥 Installing fraim-framework with unpinned chalk...');
+        const installResult = await runCommand('npm', ['install', tarballPath, '--silent'], tempDir);
+        if (installResult.code !== 0) {
+            console.log('   ❌ npm install failed');
+            console.log(`   stderr: ${installResult.stderr.substring(0, 500)}`);
+            fs_1.default.unlinkSync(tarballPath);
+            return false;
+        }
+        console.log('   ✅ fraim-framework installed');
+        // 6. Check which version of chalk was installed
+        const chalkPackageJsonPath = path_1.default.join(tempDir, 'node_modules', 'chalk', 'package.json');
+        if (!fs_1.default.existsSync(chalkPackageJsonPath)) {
+            console.log('   ❌ chalk not found in node_modules');
+            fs_1.default.unlinkSync(tarballPath);
+            return false;
+        }
+        const chalkPackageJson = JSON.parse(fs_1.default.readFileSync(chalkPackageJsonPath, 'utf-8'));
+        console.log(`   📋 Installed chalk version: ${chalkPackageJson.version}`);
+        // 7. Try to load fraim CLI
+        const testScript = `
+const fraimCli = require('./node_modules/fraim-framework/dist/src/cli/fraim.js');
+console.log('✅ fraim CLI loaded successfully');
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        const testResult = await runCommand('node', ['test.js'], tempDir);
+        // With ^4.1.2, it MIGHT install v5 in some scenarios, causing ERR_REQUIRE_ESM
+        if (testResult.code !== 0) {
+            if (testResult.stderr.includes('ERR_REQUIRE_ESM')) {
+                console.log('   ⚠️  Got ERR_REQUIRE_ESM error (this is the bug we fixed!)');
+                console.log(`   📋 Chalk version that caused issue: ${chalkPackageJson.version}`);
+                console.log('   ✅ Test successfully reproduced the original issue');
+                fs_1.default.unlinkSync(tarballPath);
+                return true; // This is expected - we reproduced the bug
+            }
+            else {
+                console.log('   ❌ Failed with unexpected error');
+                console.log(`   stderr: ${testResult.stderr.substring(0, 500)}`);
+                fs_1.default.unlinkSync(tarballPath);
+                return false;
+            }
+        }
+        // If it worked, that's also fine - means npm resolved to v4
+        console.log('   ✅ fraim CLI works (npm resolved to v4)');
+        console.log('   ℹ️  Note: ^4.1.2 worked this time, but could fail in other environments');
+        // Cleanup tarball
+        fs_1.default.unlinkSync(tarballPath);
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed with error:', error);
+        return false;
+    }
+    finally {
+        // Cleanup
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            console.log('   🧹 Cleaned up temp directory');
+        }
+        catch (e) {
+            console.log('   ⚠️  Could not clean up temp directory');
+        }
+    }
+}
+async function runFraimInstallTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'FRAIM Install with Pinned Chalk',
+        description: 'Verifies fraim-framework installs correctly with chalk pinned to 4.1.2',
+        testFunction: testFraimInstallWithPinnedChalk,
+        tags: ['integration', 'install', 'chalk']
+    },
+    {
+        name: 'FRAIM Install with Unpinned Chalk',
+        description: 'Tests fraim-framework with ^4.1.2 to see if it can reproduce the issue',
+        testFunction: testFraimInstallWithUnpinnedChalk,
+        tags: ['integration', 'install', 'chalk', 'reproduction']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runFraimInstallTest, 'FRAIM Install Chalk Issue Test');

package/dist/tests/test-fraim-issues.js

@@ -0,0 +1,59 @@
+"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 node_assert_1 = __importDefault(require("node:assert"));
+const issues_1 = require("../src/fraim/issues");
+async function testDryRun() {
+    console.log('   Testing dry-run issue creation...');
+    const result = await (0, issues_1.fileFraimIssue)({
+        title: 'Test Issue',
+        body: 'Test Body',
+        dryRun: true
+    });
+    node_assert_1.default.strictEqual(result.success, true, 'Dry run should succeed');
+    node_assert_1.default.strictEqual(result.dryRun, true, 'Result should indicate dry run');
+    node_assert_1.default.ok(result.message && result.message.includes('[DRY RUN]'), 'Message should indicate dry run');
+    return true;
+}
+async function testMissingToken() {
+    console.log('   Testing missing GITHUB_TOKEN...');
+    // Save original token
+    const originalToken = process.env.GITHUB_TOKEN;
+    delete process.env.GITHUB_TOKEN;
+    try {
+        const result = await (0, issues_1.fileFraimIssue)({
+            title: 'Test Issue',
+            body: 'Test Body'
+        });
+        node_assert_1.default.strictEqual(result.success, false, 'Should fail without token');
+        node_assert_1.default.strictEqual(result.message, 'GITHUB_TOKEN environment variable is required', 'Should return correct error message');
+        return true;
+    }
+    finally {
+        // Restore token
+        if (originalToken) {
+            process.env.GITHUB_TOKEN = originalToken;
+        }
+    }
+}
+async function runIssueTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Dry Run Issue Creation',
+        description: 'Verifies that dry-run mode works and returns correct structure',
+        testFunction: testDryRun,
+        tags: ['issues', 'core']
+    },
+    {
+        name: 'Missing Token Validation',
+        description: 'Verifies that missing GITHUB_TOKEN causes failure',
+        testFunction: testMissingToken,
+        tags: ['issues', 'core']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runIssueTest, 'Fraim Issue Logic Tests');

package/dist/tests/test-genericization.js

@@ -12,9 +12,7 @@ async function testConfigDefaults() {
     try {
         node_assert_1.default.strictEqual(types_1.DEFAULT_FRAIM_CONFIG.persona.name, 'AI Agent', 'Default persona name should be "AI Agent"');
         node_assert_1.default.ok(types_1.DEFAULT_FRAIM_CONFIG.customizations?.workflowsPath, 'workflowsPath should exist');
-        node_assert_1.default.ok(types_1.DEFAULT_FRAIM_CONFIG.architecture, 'architecture should be restored');
-        node_assert_1.default.ok(types_1.DEFAULT_FRAIM_CONFIG.testing, 'testing should be restored');
-        node_assert_1.default.ok(!types_1.DEFAULT_FRAIM_CONFIG.mcp, 'mcp should still be removed');
+        // Architecture and Testing sections removed
         return true;
     }
     catch (e) {