fraim-framework 2.0.27 → 2.0.33

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',

package/dist/tests/test-end-to-end-hybrid-validation.js

@@ -0,0 +1,349 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 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 testCompleteHybridWorkflow() {
+    console.log('   🚀 Testing Complete Hybrid Workflow...');
+    const tempProjectDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-e2e-hybrid-'));
+    const userFraimDir = path_1.default.join(os_1.default.homedir(), '.fraim-e2e-test');
+    try {
+        // Clean up any existing test user directory
+        if (fs_1.default.existsSync(userFraimDir)) {
+            fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+        }
+        console.log(`   📂 Project dir: ${tempProjectDir}`);
+        console.log(`   🏠 User dir: ${userFraimDir}`);
+        // Set up git repository
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        execSync('git init', { cwd: tempProjectDir });
+        execSync('git remote add origin https://github.com/test-owner/e2e-hybrid-test.git', { cwd: tempProjectDir });
+        // Run fraim init with custom user directory
+        const platform = process.platform;
+        const npx = platform === 'win32' ? 'npx.cmd' : 'npx';
+        const cliScript = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
+        const runFraim = (args) => {
+            return new Promise((resolve) => {
+                const ps = (0, node_child_process_1.spawn)(npx, ['node', `"${cliScript}"`, ...args], {
+                    cwd: tempProjectDir,
+                    env: {
+                        ...process.env,
+                        TEST_MODE: 'true',
+                        FRAIM_USER_DIR: userFraimDir
+                    },
+                    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 });
+                });
+            });
+        };
+        // Initialize FRAIM
+        console.log('   Initializing FRAIM...');
+        const initRes = await runFraim(['init']);
+        node_assert_1.default.strictEqual(initRes.code, 0, 'Init should succeed');
+        // Verify user scripts directory was created and populated
+        const userScriptsDir = path_1.default.join(userFraimDir, 'scripts');
+        node_assert_1.default.ok(fs_1.default.existsSync(userScriptsDir), 'User scripts directory should exist');
+        // Verify self-contained scripts were synced
+        const expectedSelfContainedScripts = [
+            'prep-issue.sh',
+            'code-quality-check.sh',
+            'exec-with-timeout.ts',
+            'evaluate-code-quality.ts'
+        ];
+        for (const scriptName of expectedSelfContainedScripts) {
+            const scriptPath = path_1.default.join(userScriptsDir, scriptName);
+            node_assert_1.default.ok(fs_1.default.existsSync(scriptPath), `Self-contained script ${scriptName} should be synced`);
+        }
+        // Verify dependent scripts were NOT synced
+        const expectedDependentScripts = [
+            'fraim-config.ts',
+            'build-scripts-generator.ts'
+        ];
+        for (const scriptName of expectedDependentScripts) {
+            const scriptPath = path_1.default.join(userScriptsDir, scriptName);
+            node_assert_1.default.ok(!fs_1.default.existsSync(scriptPath), `Dependent script ${scriptName} should NOT be synced`);
+        }
+        // Test that self-contained scripts can execute from user directory
+        console.log('   Testing self-contained script execution...');
+        // Create a simple test script to verify execution context
+        const testScript = `#!/usr/bin/env node
+console.log('WORKING_DIR=' + process.cwd());
+console.log('SCRIPT_DIR=' + __dirname);
+
+// Verify we can read project config
+const fs = require('fs');
+const path = require('path');
+
+try {
+    const configPath = path.join(process.cwd(), '.fraim', 'config.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    console.log('PROJECT_NAME=' + config.project.name);
+    console.log('SUCCESS=true');
+} catch (error) {
+    console.log('ERROR=' + error.message);
+    console.log('SUCCESS=false');
+}
+`;
+        const testScriptPath = path_1.default.join(userScriptsDir, 'test-execution.js');
+        fs_1.default.writeFileSync(testScriptPath, testScript);
+        // Execute the test script from project directory
+        let output;
+        try {
+            output = execSync(`node "${testScriptPath}"`, {
+                cwd: tempProjectDir,
+                encoding: 'utf-8'
+            });
+        }
+        catch (error) {
+            throw new Error(`Script execution failed: ${error.message}`);
+        }
+        // Validate execution results
+        node_assert_1.default.ok(output.includes('SUCCESS=true'), 'Script should execute successfully');
+        node_assert_1.default.ok(output.includes('PROJECT_NAME=e2e-hybrid-test'), 'Should read project config correctly');
+        // Verify working directory vs script directory are different
+        const workingDirMatch = output.match(/WORKING_DIR=(.+)/);
+        const scriptDirMatch = output.match(/SCRIPT_DIR=(.+)/);
+        if (workingDirMatch && scriptDirMatch) {
+            const workingDir = workingDirMatch[1].trim();
+            const scriptDir = scriptDirMatch[1].trim();
+            node_assert_1.default.notStrictEqual(workingDir, scriptDir, 'Working directory should be different from script directory');
+        }
+        // Test sync command updates
+        console.log('   Testing sync command...');
+        const syncRes = await runFraim(['sync']);
+        // Sync might warn but should not fail completely
+        if (syncRes.code !== 0) {
+            console.log('   ⚠️ Sync returned non-zero (environment dependent)');
+        }
+        // Verify scripts are still present after sync
+        for (const scriptName of expectedSelfContainedScripts) {
+            const scriptPath = path_1.default.join(userScriptsDir, scriptName);
+            node_assert_1.default.ok(fs_1.default.existsSync(scriptPath), `Script ${scriptName} should still exist after sync`);
+        }
+        console.log('   ✅ Complete hybrid workflow verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ End-to-end hybrid test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempProjectDir, { recursive: true, force: true });
+            if (fs_1.default.existsSync(userFraimDir)) {
+                fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+            }
+        }
+        catch (e) { }
+    }
+}
+async function testScriptCategorizationAccuracy() {
+    console.log('   🚀 Testing Script Categorization Accuracy...');
+    try {
+        const registryPath = path_1.default.resolve(__dirname, '../registry');
+        if (!fs_1.default.existsSync(registryPath)) {
+            console.log('   ⚠️ Registry not found, skipping categorization accuracy test');
+            return true;
+        }
+        const { getRegistryScripts, getDependentRegistryScripts, isScriptSelfContained } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        const selfContainedScripts = getRegistryScripts(registryPath);
+        const dependentScripts = getDependentRegistryScripts(registryPath);
+        console.log(`   📊 Categorization results:`);
+        console.log(`     Self-contained: ${selfContainedScripts.length} scripts`);
+        console.log(`     Dependent: ${dependentScripts.length} scripts`);
+        // Verify specific known categorizations
+        const knownSelfContained = [
+            'prep-issue.sh',
+            'code-quality-check.sh',
+            'exec-with-timeout.ts',
+            'evaluate-code-quality.ts'
+        ];
+        const knownDependent = [
+            'fraim-config.ts',
+            'build-scripts-generator.ts'
+        ];
+        const selfContainedNames = selfContainedScripts.map(p => path_1.default.basename(p));
+        const dependentNames = dependentScripts.map(p => path_1.default.basename(p));
+        for (const scriptName of knownSelfContained) {
+            const scriptPath = path_1.default.join(registryPath, 'scripts', scriptName);
+            if (fs_1.default.existsSync(scriptPath)) {
+                node_assert_1.default.ok(selfContainedNames.includes(scriptName), `${scriptName} should be categorized as self-contained`);
+                node_assert_1.default.ok(isScriptSelfContained(scriptPath), `${scriptName} should be detected as self-contained`);
+            }
+        }
+        for (const scriptName of knownDependent) {
+            const scriptPath = path_1.default.join(registryPath, 'scripts', scriptName);
+            if (fs_1.default.existsSync(scriptPath)) {
+                node_assert_1.default.ok(dependentNames.includes(scriptName), `${scriptName} should be categorized as dependent`);
+                node_assert_1.default.ok(!isScriptSelfContained(scriptPath), `${scriptName} should be detected as dependent`);
+            }
+        }
+        // Verify no script is in both categories
+        const intersection = selfContainedNames.filter(name => dependentNames.includes(name));
+        node_assert_1.default.strictEqual(intersection.length, 0, 'No script should be in both categories');
+        // Verify all scripts are categorized
+        const allScripts = fs_1.default.readdirSync(path_1.default.join(registryPath, 'scripts'))
+            .filter(file => file.endsWith('.sh') || file.endsWith('.ts') || file.endsWith('.js'));
+        const categorizedScripts = [...selfContainedNames, ...dependentNames];
+        const uncategorized = allScripts.filter(script => !categorizedScripts.includes(script));
+        node_assert_1.default.strictEqual(uncategorized.length, 0, `All scripts should be categorized. Uncategorized: ${uncategorized.join(', ')}`);
+        console.log('   ✅ Script categorization accuracy verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Script categorization accuracy test failed:', error);
+        return false;
+    }
+}
+async function testWorkflowInstructionConsistency() {
+    console.log('   🚀 Testing Workflow Instruction Consistency...');
+    try {
+        const registryPath = path_1.default.resolve(__dirname, '../registry');
+        if (!fs_1.default.existsSync(registryPath)) {
+            console.log('   ⚠️ Registry not found, skipping workflow consistency test');
+            return true;
+        }
+        // Check that workflows use the correct execution patterns
+        const workflowsPath = path_1.default.join(registryPath, 'workflows');
+        const rulesPath = path_1.default.join(registryPath, 'rules');
+        // Get all markdown files
+        const getMarkdownFiles = (dir) => {
+            if (!fs_1.default.existsSync(dir))
+                return [];
+            const 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(...getMarkdownFiles(fullPath));
+                }
+                else if (entry.name.endsWith('.md')) {
+                    files.push(fullPath);
+                }
+            }
+            return files;
+        };
+        const allMarkdownFiles = [
+            ...getMarkdownFiles(workflowsPath),
+            ...getMarkdownFiles(rulesPath)
+        ];
+        let inconsistencies = 0;
+        for (const filePath of allMarkdownFiles) {
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            const relativePath = path_1.default.relative(registryPath, filePath);
+            // Check for old ephemeral execution patterns (but allow them for dependent scripts)
+            const oldPatterns = [
+                /tmp\/.*\.ts/g,
+                /tmp\/.*\.sh/g
+            ];
+            for (const pattern of oldPatterns) {
+                const matches = content.match(pattern);
+                if (matches) {
+                    // Allow tmp/ usage if it's accompanied by get_fraim_file (ephemeral execution for dependent scripts)
+                    const hasGetFramFile = /get_fraim_file.*scripts/.test(content);
+                    if (!hasGetFramFile) {
+                        console.log(`   ⚠️ Found old pattern in ${relativePath}: ${matches.join(', ')}`);
+                        inconsistencies++;
+                    }
+                }
+            }
+            // Check for correct hybrid patterns
+            const hybridPatterns = [
+                /~\/\.fraim\/scripts\/.*\.ts/g,
+                /~\/\.fraim\/scripts\/.*\.sh/g,
+                /%USERPROFILE%\\\.fraim\\scripts\\/g
+            ];
+            let hasHybridPatterns = false;
+            for (const pattern of hybridPatterns) {
+                if (pattern.test(content)) {
+                    hasHybridPatterns = true;
+                    break;
+                }
+            }
+            // If file mentions scripts but doesn't use hybrid patterns, it might be an issue
+            if (content.includes('scripts/') && !hasHybridPatterns && inconsistencies === 0) {
+                // This is just informational, not necessarily an error
+                console.log(`   ℹ️ File ${relativePath} mentions scripts but may not use hybrid patterns`);
+            }
+        }
+        if (inconsistencies > 0) {
+            console.log(`   ❌ Found ${inconsistencies} workflow instruction inconsistencies`);
+            return false;
+        }
+        console.log('   ✅ Workflow instruction consistency verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Workflow instruction consistency test failed:', error);
+        return false;
+    }
+}
+async function runEndToEndTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Complete Hybrid Workflow',
+        description: 'Tests the entire hybrid script execution workflow from init to execution',
+        testFunction: testCompleteHybridWorkflow,
+        tags: ['e2e', 'hybrid', 'workflow']
+    },
+    {
+        name: 'Script Categorization Accuracy',
+        description: 'Validates that all scripts are correctly categorized as self-contained or dependent',
+        testFunction: testScriptCategorizationAccuracy,
+        tags: ['e2e', 'categorization', 'validation']
+    },
+    {
+        name: 'Workflow Instruction Consistency',
+        description: 'Ensures all workflow files use the correct hybrid execution patterns',
+        testFunction: testWorkflowInstructionConsistency,
+        tags: ['e2e', 'consistency', 'workflows']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runEndToEndTest, 'End-to-End Hybrid Validation Tests');

package/dist/tests/test-first-run-journey.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -13,11 +46,10 @@ const os_1 = __importDefault(require("os"));
  * Helper to run the interactive first-run experience within 'fraim init'
  */
 async function runInteractiveInit(cwd, interactions) {
-    const projectRoot = path_1.default.resolve(__dirname, '..');
-    const cliScript = path_1.default.resolve(projectRoot, 'src/cli/fraim.ts');
+    const cliScript = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
     const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
     return new Promise(resolve => {
-        const ps = (0, node_child_process_1.spawn)(npx, ['tsx', `"${cliScript}"`, 'init'], {
+        const ps = (0, node_child_process_1.spawn)(npx, ['node', `"${cliScript}"`, 'init'], {
             cwd,
             env: { ...process.env, CI: 'false', TEST_MODE: 'false' },
             shell: true,
@@ -57,6 +89,10 @@ const testCases = [
         testFunction: async () => {
             const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-1-'));
             try {
+                // Set up git repository with remote (required for new init logic)
+                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/test-repo.git', { cwd: tempDir });
                 const res = await runInteractiveInit(tempDir, [
                     { prompt: 'Do you have a FRAIM key?', response: 'key-123' },
                     { prompt: 'Do you have an architecture document', response: 'n' }
@@ -83,6 +119,10 @@ const testCases = [
             const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-2-'));
             const archPath = 'docs/my-architecture.md';
             try {
+                // Set up git repository with remote (required for new init logic)
+                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/test-repo.git', { cwd: tempDir });
                 fs_1.default.mkdirSync(path_1.default.join(tempDir, '.fraim'), { recursive: true });
                 fs_1.default.writeFileSync(path_1.default.join(tempDir, '.fraim', 'config.json'), JSON.stringify({ version: '1.0.0' }));
                 fs_1.default.mkdirSync(path_1.default.join(tempDir, 'docs'), { recursive: true });