fraim-framework 2.0.30 → 2.0.33

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)();
@@ -134,7 +135,23 @@ const runSync = async (options) => {
         }
     }
     fs_1.default.writeFileSync(digestPath, currentDigest);
-    console.log(chalk_1.default.green(`\n✅ Sync complete. Generated ${generatedStubs.length} stubs.`));
+    console.log(chalk_1.default.green(`\n✅ Workflow sync complete. Generated ${generatedStubs.length} stubs.`));
+    // Sync scripts to user directory
+    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} self-contained scripts, removed ${cleanedScriptCount} obsolete scripts.`));
+        if (syncResult.ephemeral > 0) {
+            console.log(chalk_1.default.gray(`   ${syncResult.ephemeral} dependent scripts will use ephemeral execution.`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.green('✅ Scripts are already in sync.'));
+        if (syncResult.ephemeral > 0) {
+            console.log(chalk_1.default.gray(`   ${syncResult.ephemeral} dependent scripts will use ephemeral execution.`));
+        }
+    }
 };
 exports.runSync = runSync;
 exports.syncCommand = new commander_1.Command('sync')

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

@@ -0,0 +1,218 @@
+"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.isScriptSelfContained = isScriptSelfContained;
+exports.getRegistryScripts = getRegistryScripts;
+exports.copyScriptToUserDirectory = copyScriptToUserDirectory;
+exports.syncScriptsToUserDirectory = syncScriptsToUserDirectory;
+exports.cleanupObsoleteUserScripts = cleanupObsoleteUserScripts;
+exports.getUserScriptPath = getUserScriptPath;
+exports.userScriptExists = userScriptExists;
+exports.getDependentRegistryScripts = getDependentRegistryScripts;
+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 });
+    }
+}
+/**
+ * Check if a script is self-contained (no relative imports to FRAIM source)
+ */
+function isScriptSelfContained(scriptPath) {
+    // Shell scripts are always considered self-contained
+    if (scriptPath.endsWith('.sh')) {
+        return true;
+    }
+    // For TypeScript/JavaScript files, check for relative imports to src/
+    if (scriptPath.endsWith('.ts') || scriptPath.endsWith('.js')) {
+        try {
+            const content = fs_1.default.readFileSync(scriptPath, 'utf-8');
+            // Look for imports that reference ../../src/ or similar patterns
+            const hasRelativeImports = /import.*['"]\.\.\/.*src\//.test(content) ||
+                /require\(['"]\.\.\/.*src\//.test(content) ||
+                /from ['"]\.\.\/.*src\//.test(content);
+            return !hasRelativeImports;
+        }
+        catch (error) {
+            // If we can't read the file, assume it's not self-contained
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Get all self-contained script files from the registry
+ */
+function getRegistryScripts(registryPath) {
+    const scriptsPath = path_1.default.join(registryPath, 'scripts');
+    if (!fs_1.default.existsSync(scriptsPath)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(scriptsPath, { withFileTypes: true });
+    const allScripts = entries
+        .filter(entry => entry.isFile() && (entry.name.endsWith('.sh') || entry.name.endsWith('.ts') || entry.name.endsWith('.js')))
+        .map(entry => path_1.default.join(scriptsPath, entry.name));
+    // Only return self-contained scripts
+    return allScripts.filter(scriptPath => isScriptSelfContained(scriptPath));
+}
+/**
+ * Copy a script file to the user scripts directory with proper permissions
+ */
+function copyScriptToUserDirectory(sourcePath, scriptName) {
+    const userScriptsDir = getUserScriptsDir();
+    const targetPath = path_1.default.join(userScriptsDir, scriptName);
+    // Copy the file
+    fs_1.default.copyFileSync(sourcePath, targetPath);
+    // Set executable permissions on Unix systems
+    if (process.platform !== 'win32' && scriptName.endsWith('.sh')) {
+        try {
+            fs_1.default.chmodSync(targetPath, 0o755);
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not set executable permissions for ${scriptName}`));
+        }
+    }
+}
+/**
+ * Sync all scripts from registry to user directory
+ */
+function syncScriptsToUserDirectory(registryPath) {
+    ensureUserFraimDirectories();
+    const selfContainedScripts = getRegistryScripts(registryPath);
+    const dependentScripts = getDependentRegistryScripts(registryPath);
+    let syncedCount = 0;
+    console.log(chalk_1.default.gray(`  Self-contained scripts (will be synced to ~/.fraim/scripts/):`));
+    for (const scriptPath of selfContainedScripts) {
+        const scriptName = path_1.default.basename(scriptPath);
+        const userScriptPath = path_1.default.join(getUserScriptsDir(), scriptName);
+        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, scriptName);
+                syncedCount++;
+                console.log(chalk_1.default.gray(`    + ${scriptName}`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`    = ${scriptName} (up to date)`));
+            }
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠️ Could not sync script ${scriptName}: ${error}`));
+        }
+    }
+    if (dependentScripts.length > 0) {
+        console.log(chalk_1.default.gray(`  Dependent scripts (will use ephemeral execution):`));
+        for (const scriptPath of dependentScripts) {
+            const scriptName = path_1.default.basename(scriptPath);
+            console.log(chalk_1.default.gray(`    ~ ${scriptName} (has FRAIM dependencies)`));
+        }
+    }
+    return { synced: syncedCount, ephemeral: dependentScripts.length };
+}
+/**
+ * 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 registryScripts = getRegistryScripts(registryPath);
+    const registryScriptNames = registryScripts.map(scriptPath => path_1.default.basename(scriptPath));
+    const userScripts = fs_1.default.readdirSync(userScriptsDir)
+        .filter(file => file.endsWith('.sh') || file.endsWith('.ts') || file.endsWith('.js'));
+    let cleanedCount = 0;
+    for (const userScript of userScripts) {
+        if (!registryScriptNames.includes(userScript)) {
+            try {
+                const userScriptPath = path_1.default.join(userScriptsDir, userScript);
+                fs_1.default.unlinkSync(userScriptPath);
+                cleanedCount++;
+                console.log(chalk_1.default.yellow(`  - ${userScript} (removed from registry)`));
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow(`⚠️ Could not remove obsolete script ${userScript}: ${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));
+}
+/**
+ * Get all dependent script files from the registry (those with FRAIM source dependencies)
+ */
+function getDependentRegistryScripts(registryPath) {
+    const scriptsPath = path_1.default.join(registryPath, 'scripts');
+    if (!fs_1.default.existsSync(scriptsPath)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(scriptsPath, { withFileTypes: true });
+    const allScripts = entries
+        .filter(entry => entry.isFile() && (entry.name.endsWith('.sh') || entry.name.endsWith('.ts') || entry.name.endsWith('.js')))
+        .map(entry => path_1.default.join(scriptsPath, entry.name));
+    // Only return scripts that have dependencies
+    return allScripts.filter(scriptPath => !isScriptSelfContained(scriptPath));
+}
+/**
+ * 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 {

package/dist/tests/test-cli.js

@@ -42,6 +42,64 @@ 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"));
+async function testRepoNameRequirement() {
+    console.log('   🚀 Testing Repo Name Requirement...');
+    // Create a temp directory for the test project
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-repo-test-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        const platform = process.platform;
+        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
+        const cliScript = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
+        // Helper to run CLI commands
+        const runFraim = (args, cwdOverride) => {
+            return new Promise((resolve) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['node', `"${cliScript}"`, ...args], {
+                    cwd: cwdOverride || tempDir,
+                    env: { ...process.env, TEST_MODE: 'true' },
+                    shell: true
+                });
+                let stdout = '';
+                let stderr = '';
+                ps.stdout.on('data', d => stdout += d.toString());
+                ps.stderr.on('data', d => stderr += d.toString());
+                ps.on('close', (code) => {
+                    resolve({ stdout, stderr, code });
+                });
+            });
+        };
+        // Test 1: Init without git should fail
+        console.log('   Testing init without git remote (should fail)...');
+        const initWithoutGit = await runFraim(['init'], tempDir);
+        node_assert_1.default.strictEqual(initWithoutGit.code, 1, 'Init without git remote should fail');
+        node_assert_1.default.ok(initWithoutGit.stdout.includes('No git remote found') || initWithoutGit.stderr.includes('No git remote found'), 'Should show git remote error');
+        // Test 2: Init with git remote should succeed and use repo name
+        console.log('   Testing init with git remote (should succeed)...');
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        execSync('git init', { cwd: tempDir });
+        execSync('git remote add origin https://github.com/test-owner/my-awesome-project.git', { cwd: tempDir });
+        const initWithGit = await runFraim(['init'], tempDir);
+        node_assert_1.default.strictEqual(initWithGit.code, 0, 'Init with git remote should succeed');
+        const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
+        node_assert_1.default.ok(fs_1.default.existsSync(configPath), 'config.json should exist');
+        const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        node_assert_1.default.strictEqual(config.project.name, 'my-awesome-project', 'project.name should use repo name');
+        node_assert_1.default.strictEqual(config.git.repoName, 'my-awesome-project', 'git.repoName should match');
+        node_assert_1.default.strictEqual(config.git.repoOwner, 'test-owner', 'git.repoOwner should be detected');
+        console.log('   ✅ Repo name requirement verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Repo name test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
 async function testCliLifecycle() {
     console.log('   🚀 Testing Fraim CLI Lifecycle...');
     // Create a temp directory for the test project
@@ -50,11 +108,11 @@ async function testCliLifecycle() {
     try {
         const platform = process.platform;
         const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
-        const cliScript = path_1.default.resolve(__dirname, '../src/cli/fraim.ts');
+        const cliScript = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
         // Helper to run CLI commands
         const runFraim = (args, cwdOverride) => {
-            return new Promise((resolve, reject) => {
-                const ps = (0, node_child_process_1.spawn)(npx, ['tsx', `"${cliScript}"`, ...args], {
+            return new Promise((resolve) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['node', `"${cliScript}"`, ...args], {
                     cwd: cwdOverride || tempDir,
                     env: { ...process.env, TEST_MODE: 'true' }, // Disable interactive first-run
                     shell: true
@@ -102,11 +160,12 @@ async function testCliLifecycle() {
         if (hasGit) {
             node_assert_1.default.strictEqual(config.git.repoOwner, 'test-owner', 'repoOwner should be detected from git');
             node_assert_1.default.strictEqual(config.git.repoName, 'test-repo', 'repoName should be detected from git');
+            node_assert_1.default.strictEqual(config.project.name, 'test-repo', 'project.name should use repo name, not folder name');
         }
         else {
             console.warn('   ⚠️ No .git found in tempDir, owner/repo detection skipped');
-            node_assert_1.default.strictEqual(config.git.repoOwner, '', 'repoOwner should be empty if no git');
-            node_assert_1.default.strictEqual(config.git.repoName, '', 'repoName should be empty if no git');
+            // Without git remote, init should fail with our new logic
+            console.warn('   ⚠️ Init should have failed without git remote in new logic');
         }
         node_assert_1.default.ok(config.customizations, 'config.customizations should exist');
         node_assert_1.default.strictEqual(config.customizations.workflowsPath, '.fraim/workflows');
@@ -157,6 +216,12 @@ async function runCliTest(testCase) {
     return await testCase.testFunction();
 }
 const testCases = [
+    {
+        name: 'Repo Name Requirement',
+        description: 'Tests that init requires git remote and uses repo name for project.name',
+        testFunction: testRepoNameRequirement,
+        tags: ['cli', 'fraim', 'git']
+    },
     {
         name: 'Fraim CLI Lifecycle',
         description: 'Tests init, sync, list, and doctor commands',