specweave 0.22.4 → 0.22.6

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

@@ -12,6 +12,7 @@ import { AgentsMdGenerator } from '../../adapters/agents-md-generator.js';
 import { getDirname } from '../../utils/esm-helpers.js';
 import { LanguageManager, isLanguageSupported, getSupportedLanguages } from '../../core/i18n/language-manager.js';
 import { getLocaleManager } from '../../core/i18n/locale-manager.js';
+import { consoleLogger } from '../../utils/logger.js';
 const __dirname = getDirname(import.meta.url);
 import { readEnvFile, parseEnvFile } from '../../utils/env-file.js';
 /**
@@ -135,6 +136,18 @@ async function createMultiProjectFolders(targetDir) {
     }
 }
 export async function initCommand(projectName, options = {}) {
+    // Initialize logger (injectable for testing)
+    const logger = options.logger ?? consoleLogger;
+    // NOTE: This CLI command is 99% user-facing output (console.log/console.error).
+    // All console.* calls in this function are legitimate user-facing exceptions
+    // as defined in CONTRIBUTING.md (colored messages, confirmations, formatted output).
+    // Logger is available for any internal debug logs if needed in future.
+    // Detect CI/non-interactive environment (use throughout function)
+    const isCI = process.env.CI === 'true' ||
+        process.env.GITHUB_ACTIONS === 'true' ||
+        process.env.GITLAB_CI === 'true' ||
+        process.env.CIRCLECI === 'true' ||
+        !process.stdin.isTTY;
     // Validate and normalize language option
     const language = options.language?.toLowerCase() || 'en';
     // Validate language if provided
@@ -182,22 +195,31 @@ export async function initCommand(projectName, options = {}) {
         const dirName = path.basename(targetDir);
         // Validate directory name is suitable for project name
         if (!/^[a-z0-9-]+$/.test(dirName)) {
-            console.log(chalk.yellow(`\n${locale.t('cli', 'init.warnings.invalidDirName', { dirName })}`));
             const suggestedName = dirName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-            const { name } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'name',
-                    message: 'Project name (for templates):',
-                    default: suggestedName,
-                    validate: (input) => {
-                        if (/^[a-z0-9-]+$/.test(input))
-                            return true;
-                        return 'Project name must be lowercase letters, numbers, and hyphens only';
+            if (isCI) {
+                // CI mode: auto-sanitize directory name without prompting
+                console.log(chalk.yellow(`\n${locale.t('cli', 'init.warnings.invalidDirName', { dirName })}`));
+                console.log(chalk.gray(`   → CI mode: Auto-sanitizing to "${suggestedName}"`));
+                finalProjectName = suggestedName;
+            }
+            else {
+                // Interactive mode: prompt user
+                console.log(chalk.yellow(`\n${locale.t('cli', 'init.warnings.invalidDirName', { dirName })}`));
+                const { name } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'name',
+                        message: 'Project name (for templates):',
+                        default: suggestedName,
+                        validate: (input) => {
+                            if (/^[a-z0-9-]+$/.test(input))
+                                return true;
+                            return 'Project name must be lowercase letters, numbers, and hyphens only';
+                        },
                     },
-                },
-            ]);
-            finalProjectName = name;
+                ]);
+                finalProjectName = name;
+            }
         }
         else {
             finalProjectName = dirName;
@@ -206,18 +228,25 @@ export async function initCommand(projectName, options = {}) {
         const allFiles = fs.readdirSync(targetDir);
         const existingFiles = allFiles.filter(f => !f.startsWith('.')); // Ignore hidden files
         if (existingFiles.length > 0 && !options.force) {
-            console.log(chalk.yellow(`\n${locale.t('cli', 'init.warnings.directoryNotEmpty', { count: existingFiles.length, plural: existingFiles.length === 1 ? '' : 's' })}`));
-            const { confirm } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirm',
-                    message: 'Initialize SpecWeave in current directory?',
-                    default: false,
-                },
-            ]);
-            if (!confirm) {
-                console.log(chalk.yellow(locale.t('cli', 'init.errors.cancelled')));
-                process.exit(0);
+            if (isCI) {
+                // CI mode: allow initialization in non-empty directory without prompting
+                console.log(chalk.yellow(`\n${locale.t('cli', 'init.warnings.directoryNotEmpty', { count: existingFiles.length, plural: existingFiles.length === 1 ? '' : 's' })}`));
+                console.log(chalk.gray(`   → CI mode: Proceeding with initialization`));
+            }
+            else {
+                console.log(chalk.yellow(`\n${locale.t('cli', 'init.warnings.directoryNotEmpty', { count: existingFiles.length, plural: existingFiles.length === 1 ? '' : 's' })}`));
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: 'Initialize SpecWeave in current directory?',
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    console.log(chalk.yellow(locale.t('cli', 'init.errors.cancelled')));
+                    process.exit(0);
+                }
             }
         }
         // Check if .specweave already exists - SMART RE-INITIALIZATION
@@ -233,23 +262,35 @@ export async function initCommand(projectName, options = {}) {
                 console.log(chalk.red('   • All documentation (.specweave/docs/)'));
                 console.log(chalk.red('   • All configuration and history'));
                 console.log(chalk.yellow('\n   💡 TIP: Use "specweave init ." (no --force) for safe updates\n'));
-                // ALWAYS require confirmation, even in force mode (safety critical!)
-                const { confirmDeletion } = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'confirmDeletion',
-                        message: chalk.red('⚠️  Type "y" to PERMANENTLY DELETE all .specweave/ data:'),
-                        default: false,
-                    },
-                ]);
-                if (!confirmDeletion) {
-                    console.log(chalk.green('\n✅ Deletion cancelled. No data lost.'));
-                    console.log(chalk.gray('   → Run "specweave init ." (without --force) for safe updates'));
-                    process.exit(0);
+                if (isCI) {
+                    // CI mode: proceed with force deletion without prompting (test environment)
+                    console.log(chalk.gray('   → CI mode: Proceeding with force deletion'));
+                    action = 'fresh';
+                }
+                else {
+                    // Interactive mode: ALWAYS require confirmation, even in force mode (safety critical!)
+                    const { confirmDeletion } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirmDeletion',
+                            message: chalk.red('⚠️  Type "y" to PERMANENTLY DELETE all .specweave/ data:'),
+                            default: false,
+                        },
+                    ]);
+                    if (!confirmDeletion) {
+                        console.log(chalk.green('\n✅ Deletion cancelled. No data lost.'));
+                        console.log(chalk.gray('   → Run "specweave init ." (without --force) for safe updates'));
+                        process.exit(0);
+                    }
+                    action = 'fresh';
                 }
-                action = 'fresh';
                 console.log(chalk.yellow('\n   🔄 Force mode: Proceeding with fresh start...'));
             }
+            else if (isCI) {
+                // CI mode: auto-continue with existing project
+                console.log(chalk.gray('   → CI mode: Continuing with existing project'));
+                action = 'continue';
+            }
             else {
                 // Interactive mode: Ask user what to do
                 const result = await inquirer.prompt([
@@ -285,6 +326,12 @@ export async function initCommand(projectName, options = {}) {
             }
             if (action === 'fresh') {
                 if (!options.force) {
+                    if (isCI) {
+                        // CI mode: NEVER allow fresh start without explicit --force flag (safety critical!)
+                        console.log(chalk.red('\n⛔ ERROR: Cannot start fresh in CI mode without --force flag'));
+                        console.log(chalk.gray('   → Use "specweave init . --force" if you really want to delete all data'));
+                        process.exit(1);
+                    }
                     // Interactive mode: Ask for confirmation (force mode already confirmed above)
                     console.log(chalk.yellow('\n⚠️  WARNING: This will DELETE all increments, docs, and configuration!'));
                     const { confirmFresh } = await inquirer.prompt([
@@ -576,12 +623,7 @@ export async function initCommand(projectName, options = {}) {
                 }
             }
             console.log('');
-            // Check if running in CI/non-interactive environment
-            const isCI = process.env.CI === 'true' ||
-                process.env.GITHUB_ACTIONS === 'true' ||
-                process.env.GITLAB_CI === 'true' ||
-                process.env.CIRCLECI === 'true' ||
-                !process.stdin.isTTY;
+            // Use function-level isCI (already defined at function start)
             let confirmTool = true; // Default to yes
             if (isCI) {
                 // In CI, automatically use detected tool without prompting
@@ -798,102 +840,8 @@ export async function initCommand(projectName, options = {}) {
                 });
             }
         }
-        // 12. Prompt for testing configuration (NEW)
-        let testMode = 'TDD';
-        let coverageTarget = 80;
-        // Only prompt if interactive (not CI)
-        const isCI = process.env.CI === 'true' ||
-            process.env.GITHUB_ACTIONS === 'true' ||
-            process.env.GITLAB_CI === 'true' ||
-            process.env.CIRCLECI === 'true' ||
-            !process.stdin.isTTY;
-        if (!isCI && !continueExisting) {
-            console.log('');
-            console.log(chalk.cyan.bold('🧪 Testing Configuration'));
-            console.log(chalk.gray('   Configure your default testing approach and coverage targets'));
-            console.log('');
-            const { selectedTestMode } = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'selectedTestMode',
-                    message: 'Select your testing approach:',
-                    choices: [
-                        {
-                            name: 'TDD (Test-Driven Development) - Write tests first',
-                            value: 'TDD',
-                            short: 'TDD'
-                        },
-                        {
-                            name: 'Test-After - Implement first, then write tests',
-                            value: 'test-after',
-                            short: 'Test-After'
-                        },
-                        {
-                            name: 'Manual Testing - No automated tests',
-                            value: 'manual',
-                            short: 'Manual'
-                        }
-                    ],
-                    default: 'TDD'
-                }
-            ]);
-            testMode = selectedTestMode;
-            const { selectedCoverageLevel } = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'selectedCoverageLevel',
-                    message: 'Select your coverage target level:',
-                    choices: [
-                        {
-                            name: '70% - Acceptable (core paths covered)',
-                            value: 70,
-                            short: '70%'
-                        },
-                        {
-                            name: '80% - Good (recommended - most paths covered)',
-                            value: 80,
-                            short: '80%'
-                        },
-                        {
-                            name: '90% - Excellent (comprehensive coverage)',
-                            value: 90,
-                            short: '90%'
-                        },
-                        {
-                            name: 'Custom (enter your own value)',
-                            value: 'custom',
-                            short: 'Custom'
-                        }
-                    ],
-                    default: 80
-                }
-            ]);
-            if (selectedCoverageLevel === 'custom') {
-                const { customCoverage } = await inquirer.prompt([
-                    {
-                        type: 'number',
-                        name: 'customCoverage',
-                        message: 'Enter custom coverage target (70-95):',
-                        default: 80,
-                        validate: (input) => {
-                            if (input >= 70 && input <= 95)
-                                return true;
-                            return 'Coverage target must be between 70% and 95%';
-                        }
-                    }
-                ]);
-                coverageTarget = customCoverage;
-            }
-            else {
-                coverageTarget = selectedCoverageLevel;
-            }
-            console.log('');
-            console.log(chalk.green(`   ✔ Testing: ${testMode}`));
-            console.log(chalk.green(`   ✔ Coverage Target: ${coverageTarget}%`));
-            console.log('');
-        }
-        // 13. Create config.json with language and testing settings
-        createConfigFile(targetDir, finalProjectName, toolName, language, false, testMode, coverageTarget);
+        // 12. Create config.json with basic settings (testing params added later)
+        createConfigFile(targetDir, finalProjectName, toolName, language, false);
         // 14. AUTO-INSTALL ALL PLUGINS via Claude CLI (Breaking Change: No selective loading)
         // NOTE: We do NOT create .claude/settings.json - marketplace registration via CLI is GLOBAL
         // and persists across all projects. settings.json would be redundant.
@@ -960,7 +908,8 @@ export async function initCommand(projectName, options = {}) {
             else {
                 // Claude CLI available → install ALL plugins from marketplace
                 try {
-                    // Step 1: FORCE marketplace refresh - remove and re-add from GitHub
+                    // Step 1: Remove existing marketplace to force update (REQUIRED for updates!)
+                    // This ensures users get the latest plugins when new ones are added
                     spinner.start('Refreshing SpecWeave marketplace...');
                     const listResult = execFileNoThrowSync('claude', [
                         'plugin',
@@ -970,16 +919,15 @@ export async function initCommand(projectName, options = {}) {
                     const marketplaceExists = listResult.success &&
                         (listResult.stdout || '').toLowerCase().includes('specweave');
                     if (marketplaceExists) {
-                        // Always remove existing marketplace to ensure fresh install
                         execFileNoThrowSync('claude', [
                             'plugin',
                             'marketplace',
                             'remove',
                             'specweave'
                         ]);
-                        console.log(chalk.blue('   🔄 Removed existing marketplace'));
+                        console.log(chalk.blue('   🔄 Removed existing marketplace for update'));
                     }
-                    // Add marketplace from GitHub (always fresh)
+                    // Step 2: Add marketplace from GitHub (always fresh)
                     const addResult = execFileNoThrowSync('claude', [
                         'plugin',
                         'marketplace',
@@ -990,7 +938,13 @@ export async function initCommand(projectName, options = {}) {
                         throw new Error('Failed to add marketplace from GitHub');
                     }
                     console.log(chalk.green('   ✔ Marketplace registered from GitHub'));
-                    spinner.succeed('SpecWeave marketplace refreshed');
+                    // CRITICAL: Wait for marketplace cache to fully initialize after remove+add
+                    // The remove operation invalidates cache, add fetches from GitHub
+                    // We need to wait for: fetch + parse + validate 25 plugins
+                    // 2 seconds was too short, increasing to 5 seconds for reliability
+                    spinner.text = 'Initializing marketplace cache (this takes a few seconds)...';
+                    await new Promise(resolve => setTimeout(resolve, 5000)); // 5 second delay
+                    spinner.succeed('SpecWeave marketplace ready');
                     // Step 2: Load marketplace.json to get ALL available plugins
                     spinner.start('Loading available plugins...');
                     const marketplaceJsonPath = findSourceDir('.claude-plugin/marketplace.json');
@@ -1004,19 +958,35 @@ export async function initCommand(projectName, options = {}) {
                     }
                     console.log(chalk.blue(`   📦 Found ${allPlugins.length} plugins to install`));
                     spinner.succeed(`Found ${allPlugins.length} plugins`);
-                    // Step 3: Install ALL plugins (no selective loading!)
+                    // Step 3: Install ALL plugins with retry logic (handles remaining race conditions)
                     let successCount = 0;
                     let failCount = 0;
                     const failedPlugins = [];
                     for (const plugin of allPlugins) {
                         const pluginName = plugin.name;
                         spinner.start(`Installing ${pluginName}...`);
-                        const installResult = execFileNoThrowSync('claude', [
-                            'plugin',
-                            'install',
-                            pluginName
-                        ]);
-                        if (installResult.success) {
+                        // Retry up to 3 times with exponential backoff
+                        let installed = false;
+                        for (let attempt = 1; attempt <= 3; attempt++) {
+                            const installResult = execFileNoThrowSync('claude', [
+                                'plugin',
+                                'install',
+                                pluginName
+                            ]);
+                            if (installResult.success) {
+                                installed = true;
+                                break;
+                            }
+                            // If "not found" error and not last attempt, wait and retry
+                            if (installResult.stderr?.includes('not found') && attempt < 3) {
+                                spinner.text = `Installing ${pluginName}... (retry ${attempt}/3)`;
+                                await new Promise(resolve => setTimeout(resolve, 500 * attempt)); // 500ms, 1s, 1.5s
+                                continue;
+                            }
+                            // Other errors or final attempt - stop retrying
+                            break;
+                        }
+                        if (installed) {
                             successCount++;
                             spinner.succeed(`${pluginName} installed`);
                         }
@@ -1101,23 +1071,29 @@ export async function initCommand(projectName, options = {}) {
                     console.log(chalk.blue('\n🔍 Existing Issue Tracker Configuration Detected'));
                     console.log(chalk.gray(`   Current: ${existingTracker.charAt(0).toUpperCase() + existingTracker.slice(1)}`));
                     console.log('');
-                    const { reconfigure } = await inquirer.prompt([{
-                            type: 'confirm',
-                            name: 'reconfigure',
-                            message: 'Do you want to reconfigure your issue tracker?',
-                            default: false
-                        }]);
-                    if (!reconfigure) {
-                        console.log(chalk.gray('   ✓ Keeping existing configuration\n'));
+                    if (isCI) {
+                        // CI mode: keep existing configuration without prompting
+                        console.log(chalk.gray('   → CI mode: Keeping existing configuration\n'));
                     }
                     else {
-                        // User wants to reconfigure - run setup
-                        await setupIssueTracker({
-                            projectPath: targetDir,
-                            language: language,
-                            maxRetries: 3,
-                            isFrameworkRepo
-                        });
+                        const { reconfigure } = await inquirer.prompt([{
+                                type: 'confirm',
+                                name: 'reconfigure',
+                                message: 'Do you want to reconfigure your issue tracker?',
+                                default: false
+                            }]);
+                        if (!reconfigure) {
+                            console.log(chalk.gray('   ✓ Keeping existing configuration\n'));
+                        }
+                        else {
+                            // User wants to reconfigure - run setup
+                            await setupIssueTracker({
+                                projectPath: targetDir,
+                                language: language,
+                                maxRetries: 3,
+                                isFrameworkRepo
+                            });
+                        }
                     }
                 }
                 else {
@@ -1154,6 +1130,122 @@ export async function initCommand(projectName, options = {}) {
                 }
             }
         }
+        // 10.7 Testing Configuration (MOVED TO END - Better UX)
+        // Prompt for testing approach and coverage targets after all setup is complete
+        // This keeps the main flow fast and asks for preferences at the end
+        let testMode = 'TDD';
+        let coverageTarget = 80;
+        // Only prompt if interactive (use function-level isCI)
+        if (!isCI && !continueExisting) {
+            console.log('');
+            console.log(chalk.cyan.bold('🧪 Testing Configuration'));
+            console.log(chalk.gray('   Configure your default testing approach and coverage targets'));
+            console.log('');
+            // Add guidance on which testing approach to choose
+            console.log(chalk.white('💡 Which testing approach should you choose?'));
+            console.log('');
+            console.log(chalk.green('   ✓ TDD (Test-Driven Development)'));
+            console.log(chalk.gray('     Best for: Complex business logic, critical features, refactoring'));
+            console.log(chalk.gray('     Benefits: Better design, fewer bugs, confidence in changes'));
+            console.log(chalk.gray('     Tradeoff: Slower initial development, requires discipline'));
+            console.log('');
+            console.log(chalk.blue('   ✓ Test-After'));
+            console.log(chalk.gray('     Best for: Most projects, rapid prototyping, exploratory work'));
+            console.log(chalk.gray('     Benefits: Fast iteration, flexible design, good coverage'));
+            console.log(chalk.gray('     Tradeoff: May miss edge cases, harder to test after design'));
+            console.log('');
+            console.log(chalk.yellow('   ✓ Manual Testing'));
+            console.log(chalk.gray('     Best for: Quick prototypes, proof-of-concepts, learning'));
+            console.log(chalk.gray('     Benefits: Fastest development, no test maintenance'));
+            console.log(chalk.gray('     Tradeoff: No safety net, regressions, hard to refactor'));
+            console.log('');
+            const { selectedTestMode } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedTestMode',
+                    message: 'Select your testing approach:',
+                    choices: [
+                        {
+                            name: '🔴 TDD - Write tests first (recommended for production apps)',
+                            value: 'TDD',
+                            short: 'TDD'
+                        },
+                        {
+                            name: '🔵 Test-After - Implement first, test later (balanced approach)',
+                            value: 'test-after',
+                            short: 'Test-After'
+                        },
+                        {
+                            name: '🟡 Manual - No automated tests (prototypes only)',
+                            value: 'manual',
+                            short: 'Manual'
+                        }
+                    ],
+                    default: 'TDD'
+                }
+            ]);
+            testMode = selectedTestMode;
+            // Only ask for coverage if not manual testing
+            if (testMode !== 'manual') {
+                const { selectedCoverageLevel } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedCoverageLevel',
+                        message: 'Select your coverage target level:',
+                        choices: [
+                            {
+                                name: '70% - Acceptable (core paths covered)',
+                                value: 70,
+                                short: '70%'
+                            },
+                            {
+                                name: '80% - Good (recommended - most paths covered)',
+                                value: 80,
+                                short: '80%'
+                            },
+                            {
+                                name: '90% - Excellent (comprehensive coverage)',
+                                value: 90,
+                                short: '90%'
+                            },
+                            {
+                                name: 'Custom (enter your own value)',
+                                value: 'custom',
+                                short: 'Custom'
+                            }
+                        ],
+                        default: 80
+                    }
+                ]);
+                if (selectedCoverageLevel === 'custom') {
+                    const { customCoverage } = await inquirer.prompt([
+                        {
+                            type: 'number',
+                            name: 'customCoverage',
+                            message: 'Enter custom coverage target (70-95):',
+                            default: 80,
+                            validate: (input) => {
+                                if (input >= 70 && input <= 95)
+                                    return true;
+                                return 'Coverage target must be between 70% and 95%';
+                            }
+                        }
+                    ]);
+                    coverageTarget = customCoverage;
+                }
+                else {
+                    coverageTarget = selectedCoverageLevel;
+                }
+            }
+            console.log('');
+            console.log(chalk.green(`   ✔ Testing: ${testMode}`));
+            if (testMode !== 'manual') {
+                console.log(chalk.green(`   ✔ Coverage Target: ${coverageTarget}%`));
+            }
+            console.log('');
+            // Update config.json with testing configuration
+            updateConfigWithTesting(targetDir, testMode, coverageTarget);
+        }
         showNextSteps(finalProjectName, toolName, language, usedDotNotation, toolName === 'claude' ? autoInstallSucceeded : undefined);
     }
     catch (error) {
@@ -1359,8 +1451,9 @@ function findSourceDir(relativePath) {
 }
 /**
  * Create .specweave/config.json with project settings
+ * Testing configuration is optional and can be added later via updateConfigWithTesting()
  */
-function createConfigFile(targetDir, projectName, adapter, language, enableDocsPreview = true, testMode = 'TDD', coverageTarget = 80) {
+function createConfigFile(targetDir, projectName, adapter, language, enableDocsPreview = true, testMode, coverageTarget) {
     const configPath = path.join(targetDir, '.specweave', 'config.json');
     const config = {
         project: {
@@ -1370,16 +1463,18 @@ function createConfigFile(targetDir, projectName, adapter, language, enableDocsP
         adapters: {
             default: adapter,
         },
-        // Testing configuration (NEW - v0.18.0+)
-        testing: {
-            defaultTestMode: testMode,
-            defaultCoverageTarget: coverageTarget,
-            coverageTargets: {
-                unit: Math.min(coverageTarget + 5, 95), // Unit tests slightly higher
-                integration: coverageTarget, // Integration at default
-                e2e: Math.min(coverageTarget + 10, 100) // E2E tests highest (critical paths)
+        // Testing configuration (NEW - v0.18.0+) - only include if provided
+        ...(testMode && coverageTarget && {
+            testing: {
+                defaultTestMode: testMode,
+                defaultCoverageTarget: coverageTarget,
+                coverageTargets: {
+                    unit: Math.min(coverageTarget + 5, 95), // Unit tests slightly higher
+                    integration: coverageTarget, // Integration at default
+                    e2e: Math.min(coverageTarget + 10, 100) // E2E tests highest (critical paths)
+                }
             }
-        },
+        }),
         // Documentation preview settings (for Claude Code only)
         ...(adapter === 'claude' && {
             documentation: {
@@ -1408,6 +1503,28 @@ function createConfigFile(targetDir, projectName, adapter, language, enableDocsP
     };
     fs.writeJsonSync(configPath, config, { spaces: 2 });
 }
+/**
+ * Update config.json with testing configuration
+ * Called after user completes testing setup prompts
+ */
+function updateConfigWithTesting(targetDir, testMode, coverageTarget) {
+    const configPath = path.join(targetDir, '.specweave', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error(chalk.red('⚠️  config.json not found, cannot update testing configuration'));
+        return;
+    }
+    const config = fs.readJsonSync(configPath);
+    config.testing = {
+        defaultTestMode: testMode,
+        defaultCoverageTarget: coverageTarget,
+        coverageTargets: {
+            unit: Math.min(coverageTarget + 5, 95),
+            integration: coverageTarget,
+            e2e: Math.min(coverageTarget + 10, 100)
+        }
+    };
+    fs.writeJsonSync(configPath, config, { spaces: 2 });
+}
 /**
  * REMOVED: setupClaudePluginAutoRegistration()
  *