fraim-framework 2.0.30 → 2.0.34

package/bin/fraim.js

@@ -1,23 +1,8 @@
 #!/usr/bin/env node
 
 /**
- * FRAIM Framework CLI Entry Point
- * 
- * This file delegates to the compiled TypeScript implementation.
+ * FRAIM CLI Entry Point
+ * This wrapper loads and executes the compiled CLI from dist/
  */
 
-try {
-    // In production/installed package, code is in dist/
-    require('../dist/src/cli/fraim.js');
-} catch (error) {
-    if (error.code === 'MODULE_NOT_FOUND') {
-        // In development (local clone), we might use tsx if dist is missing
-        // But typically we should just tell user to build.
-        console.error('❌ Could not find FRAIM CLI implementation.');
-        console.error('   If you are running from source, please run "npm run build" first.');
-        console.error(`   Error details: ${error.message}`);
-        process.exit(1);
-    } else {
-        throw error;
-    }
-}
+require('../dist/src/cli/fraim.js');

package/dist/src/cli/commands/init.js

@@ -13,6 +13,7 @@ const sync_1 = require("./sync");
 const types_1 = require("../../fraim/types");
 const git_utils_1 = require("../../utils/git-utils");
 const version_utils_1 = require("../../utils/version-utils");
+const script_sync_utils_1 = require("../../utils/script-sync-utils");
 const runInit = async () => {
     const projectRoot = process.cwd();
     const fraimDir = path_1.default.join(projectRoot, '.fraim');
@@ -27,17 +28,23 @@ const runInit = async () => {
     }
     if (!fs_1.default.existsSync(configPath)) {
         const remoteInfo = (0, git_utils_1.getGitRemoteInfo)();
+        if (!remoteInfo.repo) {
+            console.log(chalk_1.default.red('❌ Error: No git remote found. FRAIM requires a git repository with remote origin.'));
+            console.log(chalk_1.default.yellow('💡 Make sure you\'re in a git repository and have set up a remote origin:'));
+            console.log(chalk_1.default.gray('   git remote add origin <your-repo-url>'));
+            process.exit(1);
+        }
         const config = {
             ...types_1.DEFAULT_FRAIM_CONFIG,
             version: (0, version_utils_1.getFraimVersion)(),
             project: {
                 ...types_1.DEFAULT_FRAIM_CONFIG.project,
-                name: path_1.default.basename(projectRoot)
+                name: remoteInfo.repo
             },
             git: {
                 ...types_1.DEFAULT_FRAIM_CONFIG.git,
                 repoOwner: remoteInfo.owner || types_1.DEFAULT_FRAIM_CONFIG.git.repoOwner,
-                repoName: remoteInfo.repo || types_1.DEFAULT_FRAIM_CONFIG.git.repoName
+                repoName: remoteInfo.repo
             }
         };
         fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
@@ -54,6 +61,26 @@ const runInit = async () => {
     console.log(chalk_1.default.blue('\n🎉 FRAIM initialized successfully!'));
     // Sync workflows from registry
     await (0, sync_1.runSync)({});
+    // Sync scripts to user directory
+    console.log(chalk_1.default.blue('🔄 Syncing FRAIM scripts to user directory...'));
+    // Find registry path (same logic as sync command)
+    let registryPath = path_1.default.join(__dirname, '../../../../registry');
+    if (!fs_1.default.existsSync(registryPath)) {
+        registryPath = path_1.default.join(__dirname, '../../../registry');
+    }
+    if (!fs_1.default.existsSync(registryPath)) {
+        registryPath = path_1.default.join(projectRoot, 'registry');
+    }
+    if (fs_1.default.existsSync(registryPath)) {
+        const syncResult = (0, script_sync_utils_1.syncScriptsToUserDirectory)(registryPath);
+        console.log(chalk_1.default.green(`✅ Synced ${syncResult.synced} self-contained scripts to user directory.`));
+        if (syncResult.ephemeral > 0) {
+            console.log(chalk_1.default.gray(`   ${syncResult.ephemeral} dependent scripts will use ephemeral execution.`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠️ Registry not found, skipping script sync.'));
+    }
     // Trigger First Run Experience
     await (0, first_run_1.runFirstRunExperience)();
     process.exit(0);

package/dist/src/cli/commands/sync.js

@@ -12,6 +12,7 @@ const digest_utils_1 = require("../../utils/digest-utils");
 const stub_generator_1 = require("../../utils/stub-generator");
 const config_loader_1 = require("../../fraim/config-loader");
 const version_utils_1 = require("../../utils/version-utils");
+const script_sync_utils_1 = require("../../utils/script-sync-utils");
 const runSync = async (options) => {
     const projectRoot = process.cwd();
     const config = (0, config_loader_1.loadFraimConfig)();
@@ -59,82 +60,93 @@ const runSync = async (options) => {
     const existingDigest = fs_1.default.existsSync(digestPath) ? fs_1.default.readFileSync(digestPath, 'utf8') : '';
     if (currentDigest === existingDigest && !options.force) {
         console.log(chalk_1.default.green('✅ Workflows are already in sync.'));
-        return;
     }
-    const registryWorkflowsPath = path_1.default.join(registryPath, 'workflows');
-    if (!fs_1.default.existsSync(registryWorkflowsPath)) {
-        console.log(chalk_1.default.yellow('⚠️ No workflows found in registry.'));
-        return;
-    }
-    // Get all workflows from registry (recursive)
-    const getFiles = (dir) => {
-        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-        const files = entries
-            .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
-            .map(e => path_1.default.join(dir, e.name));
-        const folders = entries.filter(e => e.isDirectory());
-        for (const folder of folders) {
-            files.push(...getFiles(path_1.default.join(dir, folder.name)));
-        }
-        return files;
-    };
-    const registryFiles = getFiles(registryWorkflowsPath);
-    const generatedStubs = [];
-    for (const file of registryFiles) {
-        const content = fs_1.default.readFileSync(file, 'utf8');
-        const { intent, principles } = (0, stub_generator_1.parseRegistryWorkflow)(content);
-        const fileName = path_1.default.basename(file);
-        const workflowName = fileName.replace('.md', '');
-        // Calculate relative path from registry/workflows to preserve structure
-        const relativePath = path_1.default.relative(registryWorkflowsPath, file);
-        const relativeDir = path_1.default.dirname(relativePath);
-        // Ensure target directory exists
-        const targetDir = path_1.default.join(workflowsDir, relativeDir);
-        if (!fs_1.default.existsSync(targetDir)) {
-            fs_1.default.mkdirSync(targetDir, { recursive: true });
+    else {
+        const registryWorkflowsPath = path_1.default.join(registryPath, 'workflows');
+        if (!fs_1.default.existsSync(registryWorkflowsPath)) {
+            console.log(chalk_1.default.yellow('⚠️ No workflows found in registry.'));
         }
-        const stubContent = (0, stub_generator_1.generateWorkflowStub)(workflowName, file, intent, principles);
-        const stubPath = path_1.default.join(targetDir, fileName);
-        fs_1.default.writeFileSync(stubPath, stubContent);
-        generatedStubs.push(relativePath); // Store relative path for cleanup tracking
-        console.log(chalk_1.default.gray(`  + ${workflowName} (${relativeDir === '.' ? 'root' : relativeDir})`));
-    }
-    // Cleanup stubs that no longer exist in registry
-    // Cleanup stubs that no longer exist in registry
-    // Helper to get all local stubs recursively
-    const getLocalStubs = (dir) => {
-        if (!fs_1.default.existsSync(dir))
-            return [];
-        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-        const files = entries
-            .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
-            .map(e => path_1.default.relative(workflowsDir, path_1.default.join(dir, e.name)));
-        const folders = entries.filter(e => e.isDirectory());
-        for (const folder of folders) {
-            files.push(...getLocalStubs(path_1.default.join(dir, folder.name)));
-        }
-        return files;
-    };
-    const localStubs = getLocalStubs(workflowsDir);
-    for (const stub of localStubs) {
-        // standardise path separators for comparison
-        const normalizedStub = stub.replace(/\\/g, '/');
-        const normalizedGenerated = generatedStubs.map(s => s.replace(/\\/g, '/'));
-        if (!normalizedGenerated.includes(normalizedStub)) {
-            fs_1.default.unlinkSync(path_1.default.join(workflowsDir, stub));
-            console.log(chalk_1.default.yellow(`  - ${stub} (removed from registry)`));
-            // Cleanup empty directories
-            try {
-                const dir = path_1.default.dirname(path_1.default.join(workflowsDir, stub));
-                if (fs_1.default.readdirSync(dir).length === 0) {
-                    fs_1.default.rmdirSync(dir);
+        else {
+            // Get all workflows from registry (recursive)
+            const getFiles = (dir) => {
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                const files = entries
+                    .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
+                    .map(e => path_1.default.join(dir, e.name));
+                const folders = entries.filter(e => e.isDirectory());
+                for (const folder of folders) {
+                    files.push(...getFiles(path_1.default.join(dir, folder.name)));
+                }
+                return files;
+            };
+            const registryFiles = getFiles(registryWorkflowsPath);
+            const generatedStubs = [];
+            for (const file of registryFiles) {
+                const content = fs_1.default.readFileSync(file, 'utf8');
+                const { intent, principles } = (0, stub_generator_1.parseRegistryWorkflow)(content);
+                const fileName = path_1.default.basename(file);
+                const workflowName = fileName.replace('.md', '');
+                // Calculate relative path from registry/workflows to preserve structure
+                const relativePath = path_1.default.relative(registryWorkflowsPath, file);
+                const relativeDir = path_1.default.dirname(relativePath);
+                // Ensure target directory exists
+                const targetDir = path_1.default.join(workflowsDir, relativeDir);
+                if (!fs_1.default.existsSync(targetDir)) {
+                    fs_1.default.mkdirSync(targetDir, { recursive: true });
                 }
+                const stubContent = (0, stub_generator_1.generateWorkflowStub)(workflowName, file, intent, principles);
+                const stubPath = path_1.default.join(targetDir, fileName);
+                fs_1.default.writeFileSync(stubPath, stubContent);
+                generatedStubs.push(relativePath); // Store relative path for cleanup tracking
+                console.log(chalk_1.default.gray(`  + ${workflowName} (${relativeDir === '.' ? 'root' : relativeDir})`));
             }
-            catch (e) { }
+            // Cleanup stubs that no longer exist in registry
+            // Helper to get all local stubs recursively
+            const getLocalStubs = (dir) => {
+                if (!fs_1.default.existsSync(dir))
+                    return [];
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                const files = entries
+                    .filter(e => !e.isDirectory() && e.name.endsWith('.md'))
+                    .map(e => path_1.default.relative(workflowsDir, path_1.default.join(dir, e.name)));
+                const folders = entries.filter(e => e.isDirectory());
+                for (const folder of folders) {
+                    files.push(...getLocalStubs(path_1.default.join(dir, folder.name)));
+                }
+                return files;
+            };
+            const localStubs = getLocalStubs(workflowsDir);
+            for (const stub of localStubs) {
+                // standardise path separators for comparison
+                const normalizedStub = stub.replace(/\\/g, '/');
+                const normalizedGenerated = generatedStubs.map(s => s.replace(/\\/g, '/'));
+                if (!normalizedGenerated.includes(normalizedStub)) {
+                    fs_1.default.unlinkSync(path_1.default.join(workflowsDir, stub));
+                    console.log(chalk_1.default.yellow(`  - ${stub} (removed from registry)`));
+                    // Cleanup empty directories
+                    try {
+                        const dir = path_1.default.dirname(path_1.default.join(workflowsDir, stub));
+                        if (fs_1.default.readdirSync(dir).length === 0) {
+                            fs_1.default.rmdirSync(dir);
+                        }
+                    }
+                    catch (e) { }
+                }
+            }
+            fs_1.default.writeFileSync(digestPath, currentDigest);
+            console.log(chalk_1.default.green(`\n✅ Workflow sync complete. Generated ${generatedStubs.length} stubs.`));
         }
     }
-    fs_1.default.writeFileSync(digestPath, currentDigest);
-    console.log(chalk_1.default.green(`\n✅ Sync complete. Generated ${generatedStubs.length} stubs.`));
+    // Always sync scripts, regardless of workflow sync status
+    console.log(chalk_1.default.blue('\n🔄 Syncing FRAIM scripts to user directory...'));
+    const syncResult = (0, script_sync_utils_1.syncScriptsToUserDirectory)(registryPath);
+    const cleanedScriptCount = (0, script_sync_utils_1.cleanupObsoleteUserScripts)(registryPath);
+    if (syncResult.synced > 0 || cleanedScriptCount > 0) {
+        console.log(chalk_1.default.green(`✅ Script sync complete. Updated ${syncResult.synced} scripts, removed ${cleanedScriptCount} obsolete scripts.`));
+    }
+    else {
+        console.log(chalk_1.default.green('✅ Scripts are already in sync.'));
+    }
 };
 exports.runSync = runSync;
 exports.syncCommand = new commander_1.Command('sync')

package/dist/src/utils/script-sync-utils.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserFraimDir = getUserFraimDir;
+exports.getUserScriptsDir = getUserScriptsDir;
+exports.ensureUserFraimDirectories = ensureUserFraimDirectories;
+exports.getRegistryScripts = getRegistryScripts;
+exports.copyScriptToUserDirectory = copyScriptToUserDirectory;
+exports.syncScriptsToUserDirectory = syncScriptsToUserDirectory;
+exports.cleanupObsoleteUserScripts = cleanupObsoleteUserScripts;
+exports.getUserScriptPath = getUserScriptPath;
+exports.userScriptExists = userScriptExists;
+exports.validateUserScripts = validateUserScripts;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Get the user-level FRAIM directory path
+ * Can be overridden with FRAIM_USER_DIR environment variable for testing
+ */
+function getUserFraimDir() {
+    return process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
+}
+/**
+ * Get the user-level scripts directory path
+ */
+function getUserScriptsDir() {
+    return path_1.default.join(getUserFraimDir(), 'scripts');
+}
+/**
+ * Ensure the user-level FRAIM directories exist
+ */
+function ensureUserFraimDirectories() {
+    const userFraimDir = getUserFraimDir();
+    const userScriptsDir = getUserScriptsDir();
+    if (!fs_1.default.existsSync(userFraimDir)) {
+        fs_1.default.mkdirSync(userFraimDir, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(userScriptsDir)) {
+        fs_1.default.mkdirSync(userScriptsDir, { recursive: true });
+    }
+}
+/**
+ * Get all script files from the registry (recursively)
+ */
+function getRegistryScripts(registryPath) {
+    const scriptsPath = path_1.default.join(registryPath, 'scripts');
+    if (!fs_1.default.existsSync(scriptsPath)) {
+        return [];
+    }
+    const getAllFiles = (dir, baseDir = dir) => {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively get files from subdirectories
+                files = files.concat(getAllFiles(fullPath, baseDir));
+            }
+            else {
+                // Include all files (not just specific extensions)
+                files.push(fullPath);
+            }
+        }
+        return files;
+    };
+    return getAllFiles(scriptsPath);
+}
+/**
+ * Copy a script file to the user scripts directory with proper permissions
+ * Preserves directory structure from registry/scripts/
+ */
+function copyScriptToUserDirectory(sourcePath, registryScriptsPath) {
+    const userScriptsDir = getUserScriptsDir();
+    // Calculate relative path from registry/scripts to preserve structure
+    const relativePath = path_1.default.relative(registryScriptsPath, sourcePath);
+    const targetPath = path_1.default.join(userScriptsDir, relativePath);
+    // Ensure target directory exists
+    const targetDir = path_1.default.dirname(targetPath);
+    if (!fs_1.default.existsSync(targetDir)) {
+        fs_1.default.mkdirSync(targetDir, { recursive: true });
+    }
+    // Copy the file
+    fs_1.default.copyFileSync(sourcePath, targetPath);
+    // Set executable permissions on Unix systems for shell scripts
+    if (process.platform !== 'win32' && sourcePath.endsWith('.sh')) {
+        try {
+            fs_1.default.chmodSync(targetPath, 0o755);
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not set executable permissions for ${relativePath}`));
+        }
+    }
+}
+/**
+ * Sync all scripts from registry to user directory
+ */
+function syncScriptsToUserDirectory(registryPath) {
+    ensureUserFraimDirectories();
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const allScripts = getRegistryScripts(registryPath);
+    let syncedCount = 0;
+    console.log(chalk_1.default.gray(`  Syncing all scripts to ~/.fraim/scripts/:`));
+    for (const scriptPath of allScripts) {
+        const relativePath = path_1.default.relative(registryScriptsPath, scriptPath);
+        const userScriptPath = path_1.default.join(getUserScriptsDir(), relativePath);
+        try {
+            // Check if script needs updating
+            let needsUpdate = true;
+            if (fs_1.default.existsSync(userScriptPath)) {
+                const registryContent = fs_1.default.readFileSync(scriptPath, 'utf-8');
+                const userContent = fs_1.default.readFileSync(userScriptPath, 'utf-8');
+                needsUpdate = registryContent !== userContent;
+            }
+            if (needsUpdate) {
+                copyScriptToUserDirectory(scriptPath, registryScriptsPath);
+                syncedCount++;
+                console.log(chalk_1.default.gray(`    + ${relativePath}`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`    = ${relativePath} (up to date)`));
+            }
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not sync script ${relativePath}: ${error}`));
+        }
+    }
+    return { synced: syncedCount, ephemeral: 0 };
+}
+/**
+ * Clean up scripts in user directory that no longer exist in registry
+ */
+function cleanupObsoleteUserScripts(registryPath) {
+    const userScriptsDir = getUserScriptsDir();
+    if (!fs_1.default.existsSync(userScriptsDir)) {
+        return 0;
+    }
+    const registryScriptsPath = path_1.default.join(registryPath, 'scripts');
+    const registryScripts = getRegistryScripts(registryPath);
+    const registryRelativePaths = registryScripts.map(scriptPath => path_1.default.relative(registryScriptsPath, scriptPath));
+    // Get all files in user scripts directory recursively
+    const getAllUserFiles = (dir, baseDir = dir) => {
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        let files = [];
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files = files.concat(getAllUserFiles(fullPath, baseDir));
+            }
+            else {
+                files.push(path_1.default.relative(baseDir, fullPath));
+            }
+        }
+        return files;
+    };
+    const userFiles = getAllUserFiles(userScriptsDir);
+    let cleanedCount = 0;
+    for (const userFile of userFiles) {
+        // Normalize path separators for comparison
+        const normalizedUserFile = userFile.replace(/\\/g, '/');
+        const normalizedRegistry = registryRelativePaths.map(p => p.replace(/\\/g, '/'));
+        if (!normalizedRegistry.includes(normalizedUserFile)) {
+            try {
+                const userFilePath = path_1.default.join(userScriptsDir, userFile);
+                fs_1.default.unlinkSync(userFilePath);
+                cleanedCount++;
+                console.log(chalk_1.default.yellow(`  - ${userFile} (removed from registry)`));
+                // Cleanup empty directories
+                try {
+                    const dir = path_1.default.dirname(userFilePath);
+                    if (fs_1.default.existsSync(dir) && fs_1.default.readdirSync(dir).length === 0) {
+                        fs_1.default.rmdirSync(dir);
+                    }
+                }
+                catch (e) { }
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow(`⚠️ Could not remove obsolete script ${userFile}: ${error}`));
+            }
+        }
+    }
+    return cleanedCount;
+}
+/**
+ * Get the path to a script in the user directory
+ */
+function getUserScriptPath(scriptName) {
+    return path_1.default.join(getUserScriptsDir(), scriptName);
+}
+/**
+ * Check if a script exists in the user directory
+ */
+function userScriptExists(scriptName) {
+    return fs_1.default.existsSync(getUserScriptPath(scriptName));
+}
+/**
+ * Validate that all expected scripts are present in user directory
+ */
+function validateUserScripts(expectedScripts) {
+    const missing = [];
+    const present = [];
+    for (const scriptName of expectedScripts) {
+        if (userScriptExists(scriptName)) {
+            present.push(scriptName);
+        }
+        else {
+            missing.push(scriptName);
+        }
+    }
+    return { missing, present };
+}

package/dist/tests/debug-tools.js

@@ -13,7 +13,7 @@ async function debugListTools() {
     console.log('   🔍 Debugging Available Tools...');
     let fraimProcess;
     let dbService;
-    const PORT = 10003;
+    const PORT = Math.floor(Math.random() * 1000) + 10000; // Random port to avoid conflicts
     const TEST_API_KEY = 'debug-tools-key';
     const BASE_URL = `http://localhost:${PORT}`;
     try {
@@ -24,8 +24,8 @@ async function debugListTools() {
         await db.collection('fraim_api_keys').updateOne({ key: TEST_API_KEY }, { $set: { userId: 'debug@test.com', orgId: 'debug-org', isActive: true, createdAt: new Date() } }, { upsert: true });
         // 2. Start server
         const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        const serverScript = path_1.default.resolve(__dirname, '../src/fraim-mcp-server.ts');
-        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${serverScript}"`], {
+        const serverScript = path_1.default.resolve(__dirname, '../dist/src/fraim-mcp-server.js');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['node', `"${serverScript}"`], {
             env: { ...process.env, FRAIM_MCP_PORT: PORT.toString(), FRAIM_SKIP_INDEX_ON_START: 'true' },
             shell: true
         });
@@ -65,8 +65,9 @@ async function debugListTools() {
     finally {
         if (dbService)
             await dbService.close().catch(() => { });
-        if (fraimProcess && fraimProcess.pid)
-            (0, tree_kill_1.default)(fraimProcess.pid);
+        if (fraimProcess && fraimProcess.pid) {
+            await new Promise((resolve) => (0, tree_kill_1.default)(fraimProcess.pid, 'SIGKILL', () => resolve()));
+        }
     }
 }
 async function runTest(testCase) {

package/dist/tests/test-chalk-regression.js

@@ -41,10 +41,21 @@ async function testChalkConflictScenario() {
     console.log('   This ensures pinned chalk v4 works even with chalk v5 present\n');
     const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'chalk-regression-'));
     console.log(`   📂 Temp dir: ${tempDir}`);
+    let tarballPath = null;
     try {
         // 1. Pack fraim-framework
         console.log('   📦 Packing fraim-framework...');
         const projectRoot = process.cwd();
+        // Clean up any existing tarballs first
+        const existingTarballs = fs_1.default.readdirSync(projectRoot).filter(f => f.startsWith('fraim-framework-') && f.endsWith('.tgz'));
+        for (const tarball of existingTarballs) {
+            try {
+                fs_1.default.unlinkSync(path_1.default.join(projectRoot, tarball));
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+        }
         const packResult = (0, node_child_process_1.execSync)('npm pack', {
             cwd: projectRoot,
             encoding: 'utf-8'
@@ -54,7 +65,7 @@ async function testChalkConflictScenario() {
             console.log('   ❌ Failed to create tarball');
             return false;
         }
-        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        tarballPath = path_1.default.join(projectRoot, tarballName);
         console.log(`   ✅ Created: ${tarballName}`);
         // 2. Create test project with chalk v5
         console.log('   📝 Creating test project with chalk v5...');
@@ -161,7 +172,9 @@ try {
                 console.log('   ⚠️  This might cause issues in some environments');
                 console.log('   ⚠️  But CLI loaded successfully, so test passes');
             }
-            fs_1.default.unlinkSync(tarballPath);
+            if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+                fs_1.default.unlinkSync(tarballPath);
+            }
             return true;
         }
         else if (hasERR_REQUIRE_ESM) {
@@ -173,19 +186,31 @@ try {
             else {
                 console.log('   ❌ fraim-framework has chalk v4 but still got error (unexpected)');
             }
-            fs_1.default.unlinkSync(tarballPath);
+            if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+                fs_1.default.unlinkSync(tarballPath);
+            }
             return false;
         }
         else {
             console.log('   ❌ Got unexpected error (exit code: ' + testResult.code + ')');
             console.log('   ❌ Check the error output above');
-            fs_1.default.unlinkSync(tarballPath);
+            if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+                fs_1.default.unlinkSync(tarballPath);
+            }
             return false;
         }
     }
     catch (error) {
         console.error('   ❌ Conflict scenario test failed with exception:', error);
         console.error('   ❌ This is likely a test infrastructure issue, not a chalk issue');
+        if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+            try {
+                fs_1.default.unlinkSync(tarballPath);
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+        }
         return false;
     }
     finally {
@@ -203,10 +228,21 @@ async function testFreshInstall() {
     console.log('   This simulates: npx fraim-framework init\n');
     const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'chalk-fresh-'));
     console.log(`   📂 Temp dir: ${tempDir}`);
+    let tarballPath = null;
     try {
         // 1. Pack fraim-framework
         console.log('   📦 Packing fraim-framework...');
         const projectRoot = process.cwd();
+        // Clean up any existing tarballs first
+        const existingTarballs = fs_1.default.readdirSync(projectRoot).filter(f => f.startsWith('fraim-framework-') && f.endsWith('.tgz'));
+        for (const tarball of existingTarballs) {
+            try {
+                fs_1.default.unlinkSync(path_1.default.join(projectRoot, tarball));
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+        }
         const packResult = (0, node_child_process_1.execSync)('npm pack', {
             cwd: projectRoot,
             encoding: 'utf-8'
@@ -216,7 +252,7 @@ async function testFreshInstall() {
             console.log('   ❌ Failed to create tarball');
             return false;
         }
-        const tarballPath = path_1.default.join(projectRoot, tarballName);
+        tarballPath = path_1.default.join(projectRoot, tarballName);
         console.log(`   ✅ Created: ${tarballName}`);
         // 2. Create empty project
         console.log('   📝 Creating empty project...');
@@ -277,24 +313,38 @@ try {
         const cliLoaded = testResult.stdout.includes('✓ FRAIM CLI loaded successfully') || testResult.stderr.includes('Usage: fraim');
         if (cliLoaded && !hasERR_REQUIRE_ESM) {
             console.log('   ✅ SUCCESS: Fresh install works correctly');
-            fs_1.default.unlinkSync(tarballPath);
+            if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+                fs_1.default.unlinkSync(tarballPath);
+            }
             return true;
         }
         else if (hasERR_REQUIRE_ESM) {
             console.log('   ❌ REGRESSION: Got ERR_REQUIRE_ESM error!');
-            fs_1.default.unlinkSync(tarballPath);
+            if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+                fs_1.default.unlinkSync(tarballPath);
+            }
             return false;
         }
         else {
             console.log('   ❌ Got unexpected error (exit code: ' + testResult.code + ')');
             console.log('   ❌ Check the error output above');
-            fs_1.default.unlinkSync(tarballPath);
+            if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+                fs_1.default.unlinkSync(tarballPath);
+            }
             return false;
         }
     }
     catch (error) {
         console.error('   ❌ Fresh install test failed with exception:', error);
         console.error('   ❌ This is likely a test infrastructure issue, not a chalk issue');
+        if (tarballPath && fs_1.default.existsSync(tarballPath)) {
+            try {
+                fs_1.default.unlinkSync(tarballPath);
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+        }
         return false;
     }
     finally {