specweave 0.28.19 → 0.28.20

package/dist/src/core/repo-structure/repo-structure-manager.js

@@ -14,24 +14,22 @@
  * - Organize specs per project/team
  * - Split tasks between repositories
  */
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync } from 'fs';
 import path from 'path';
 import chalk from 'chalk';
-import { select, input, confirm, number } from '@inquirer/prompts';
+import { select, input, confirm } from '@inquirer/prompts';
 import ora from 'ora';
 import { execSync } from 'child_process';
-import { execFileNoThrowSync } from '../../utils/execFileNoThrow.js';
-import { normalizeRepoName, suggestRepoName } from './repo-id-generator.js';
 import { SetupStateManager } from './setup-state-manager.js';
 import { generateEnvFile } from '../../utils/env-file-generator.js';
 import { generateSetupSummary } from './setup-summary.js';
-import { getArchitecturePrompt, getParentRepoBenefits, getVisibilityPrompt, getUrlTypePrompt } from './prompt-consolidator.js';
-import { detectRepositoryHints } from './folder-detector.js';
-import { discoverRepositories } from './repo-bulk-discovery.js';
-import { Octokit } from '@octokit/rest';
+import { getArchitecturePrompt, getVisibilityPrompt, getUrlTypePrompt } from './prompt-consolidator.js';
 import { initializeProviders } from './providers/index.js';
 import { getPlatformRegistry } from './platform-registry.js';
 import { getPlatformSelectionPrompt } from './prompt-consolidator.js';
+// Extracted modules to reduce file size and prevent crashes
+import { configureMultiRepo } from './multi-repo-configurator.js';
+import { initializeLocalRepos as initLocalRepos, createSpecWeaveStructure as createSpecWeaveStruct } from './repo-initializer.js';
 export class RepoStructureManager {
     constructor(projectPath, githubToken) {
         this.projectPath = projectPath;
@@ -125,7 +123,16 @@ export class RepoStructureManager {
                 return this.configureSingleRepo(urlType, platform, provider);
             case 'parent':
                 // GitHub parent repo (pushed to GitHub)
-                return this.configureMultiRepo(true, false, urlType, platform, provider);
+                return configureMultiRepo({
+                    projectPath: this.projectPath,
+                    githubToken: this.githubToken,
+                    stateManager: this.stateManager,
+                    useParent: true,
+                    isLocalParent: false,
+                    urlType,
+                    platform: platform,
+                    provider
+                });
             default:
                 throw new Error(`Unknown architecture: ${architecture}`);
         }
@@ -313,612 +320,6 @@ export class RepoStructureManager {
                 }]
         };
     }
-    /**
-     * Configure multi-repository architecture
-     * @param useParent - Whether to use parent repository/folder
-     * @param isLocalParent - If true, parent folder is local only (NOT pushed to GitHub)
-     * @param urlType - Git remote URL format (ssh or https)
-     * @param platform - Git hosting platform type
-     * @param provider - Git provider instance for API operations
-     *
-     * NOTE: This is primarily user-facing output (console.log/console.error).
-     * All console.* calls in this method are legitimate user-facing exceptions
-     * as defined in CONTRIBUTING.md (colored messages, confirmations, formatted output).
-     */
-    async configureMultiRepo(useParent = true, isLocalParent = false, urlType = 'ssh', platform = 'github', provider) {
-        console.log(chalk.cyan('\n🎯 Multi-Repository Configuration\n'));
-        console.log(chalk.gray('This creates separate repositories for each service/component.\n'));
-        // Show parent repo benefits if using parent approach
-        if (useParent) {
-            console.log(chalk.blue(getParentRepoBenefits()));
-            console.log('');
-        }
-        const config = {
-            architecture: useParent ? 'parent' : 'multi-repo',
-            urlType,
-            platform,
-            provider,
-            repositories: []
-        };
-        // Save state: architecture selected
-        await this.saveSetupState({
-            version: '1.0.0',
-            architecture: useParent ? 'parent' : 'multi-repo',
-            parentRepo: undefined,
-            repos: [],
-            currentStep: 'architecture-selected',
-            timestamp: new Date().toISOString(),
-            envCreated: false
-        });
-        // ========== NEW FLOW: Ask discovery strategy FIRST (before parent questions!) ==========
-        // Step 1: Ask how to configure implementation repositories (BEFORE parent questions)
-        let discoveryStrategy = 'manual';
-        let discoveredRepos = [];
-        let owner = '';
-        if (!isLocalParent && this.githubToken && useParent) {
-            console.log(chalk.cyan('\n🚀 Repository Discovery\n'));
-            console.log(chalk.gray('You\'re setting up multiple repositories. We can discover them automatically!\n'));
-            const configMethod = await select({
-                message: 'How do you want to configure repositories?',
-                choices: [
-                    {
-                        name: [
-                            chalk.bold.green('🎯 Bulk Discovery (RECOMMENDED)'),
-                            chalk.gray('  Automatically discover repos from ' + provider.config.name),
-                            chalk.gray('  • Select parent from discovered list'),
-                            chalk.gray('  • Auto-configure implementation repos'),
-                            chalk.gray('  • Supports: all, pattern, regex filtering'),
-                            ''
-                        ].join('\n'),
-                        value: 'bulk-discovery'
-                    },
-                    {
-                        name: [
-                            chalk.bold('✏️  Manual Entry'),
-                            chalk.gray('  Enter each repository manually'),
-                            chalk.gray('  • Full control over settings'),
-                            chalk.gray('  • Best for new repos or custom setup'),
-                            ''
-                        ].join('\n'),
-                        value: 'manual'
-                    }
-                ],
-                default: 'bulk-discovery'
-            });
-            discoveryStrategy = configMethod;
-        }
-        // Step 2: If bulk discovery, discover repos FIRST, then ask which is parent
-        if (discoveryStrategy === 'bulk-discovery') {
-            // Get owner FIRST (needed for discovery)
-            console.log(chalk.cyan('\n👤 Repository Owner\n'));
-            owner = await input({
-                message: `${provider.config.name} owner/organization:`,
-                validate: async (val) => {
-                    if (!val.trim())
-                        return 'Owner is required';
-                    // Validate owner exists on the platform
-                    if (this.githubToken) {
-                        const result = await provider.validateOwner(val, this.githubToken);
-                        if (!result.valid) {
-                            return result.error || `Invalid ${provider.config.name} owner`;
-                        }
-                    }
-                    return true;
-                }
-            });
-            // Discover repositories via pattern matching
-            const octokit = new Octokit({ auth: this.githubToken });
-            const isOrg = await provider.isOrganization(owner, this.githubToken);
-            // Retry loop for pattern adjustment
-            let discoveryResult = null;
-            while (discoveryResult === null) {
-                // Discovery-first flow: skip count validation since user discovers THEN selects
-                discoveryResult = await discoverRepositories(octokit, owner, isOrg, 0, { skipValidation: true });
-                // If null, user selected "go back and adjust pattern", loop will retry
-                // If user selected "manual", discoveryResult will be { repositories: [], strategy: 'manual' }
-            }
-            if (discoveryResult && discoveryResult.strategy !== 'manual') {
-                discoveredRepos = discoveryResult.repositories;
-                // Now ask: Which repo is the parent?
-                console.log(chalk.cyan('\n🏠 Select Parent Repository\n'));
-                console.log(chalk.gray('Choose which repository will be the parent (contains .specweave/ structure)\n'));
-                const parentChoices = [
-                    ...discoveredRepos.map((repo, index) => ({
-                        name: `${chalk.bold(repo.name)}\n${chalk.gray(repo.description || '(no description)')}`,
-                        value: index.toString(),
-                        short: repo.name
-                    })),
-                    {
-                        name: `${chalk.yellow('✏️  Enter parent manually')} ${chalk.gray('(not in discovered list)')}`,
-                        value: 'manual',
-                        short: 'Enter manually'
-                    }
-                ];
-                const parentSelection = await select({
-                    message: 'Which repository is the parent?',
-                    choices: parentChoices,
-                    pageSize: 15
-                });
-                if (parentSelection === 'manual') {
-                    // User wants to enter parent manually - fall back to old flow
-                    discoveryStrategy = 'manual';
-                    discoveredRepos = []; // Clear discovered repos
-                }
-                else {
-                    // User selected a parent from discovered list
-                    const parentIndex = parseInt(parentSelection);
-                    const selectedParent = discoveredRepos[parentIndex];
-                    // Fetch full repo details from GitHub API
-                    let description = selectedParent.description || 'SpecWeave parent repository - specs, docs, and architecture';
-                    let existingVisibility = selectedParent.private ? 'private' : 'public';
-                    try {
-                        const response = await fetch(`https://api.github.com/repos/${owner}/${selectedParent.name}`, {
-                            headers: {
-                                'Authorization': `Bearer ${this.githubToken}`,
-                                'Accept': 'application/vnd.github+json'
-                            }
-                        });
-                        if (response.ok) {
-                            const data = await response.json();
-                            description = data.description || description;
-                            existingVisibility = data.private ? 'private' : 'public';
-                        }
-                    }
-                    catch {
-                        // Use defaults if fetch fails
-                    }
-                    // Set parent config
-                    config.parentRepo = {
-                        name: selectedParent.name,
-                        owner: owner,
-                        description: description,
-                        visibility: existingVisibility,
-                        createOnGitHub: false // Already exists!
-                    };
-                    // Remove parent from discovered repos (implementation repos = discovered - parent)
-                    discoveredRepos.splice(parentIndex, 1);
-                    console.log(chalk.green(`\n✓ Using existing repository: ${owner}/${selectedParent.name}\n`));
-                    console.log(chalk.gray(`✓ Implementation repositories: ${discoveredRepos.length}\n`));
-                    // Save state: parent repo configured
-                    await this.saveSetupState({
-                        version: '1.0.0',
-                        architecture: useParent ? 'parent' : 'multi-repo',
-                        parentRepo: config.parentRepo,
-                        repos: [],
-                        currentStep: 'parent-repo-configured',
-                        timestamp: new Date().toISOString(),
-                        envCreated: false
-                    });
-                    // Skip to repository configuration (lines 794+)
-                    // We'll continue below with discoveredRepos
-                }
-            }
-            else {
-                // User selected manual - fall back to old flow
-                discoveryStrategy = 'manual';
-            }
-        }
-        // Step 3: Manual flow (existing logic) - only runs if discoveryStrategy === 'manual'
-        if (discoveryStrategy === 'manual' && useParent) {
-            let parentAnswers;
-            if (isLocalParent) {
-                // Local parent: Skip GitHub questions, just ask for folder name
-                console.log(chalk.blue('\n💡 Local Parent Folder Setup'));
-                console.log(chalk.gray('This folder will contain .specweave/ but will NOT be pushed to GitHub.\n'));
-                const parentNameAnswer = await input({
-                    message: 'Parent folder name:',
-                    default: `${path.basename(this.projectPath)}`,
-                    validate: (val) => {
-                        if (!val.trim())
-                            return 'Folder name is required';
-                        return true;
-                    }
-                });
-                const ownerForLocalAnswer = await input({
-                    message: `${provider.config.name} owner/organization for IMPLEMENTATION repos:`,
-                    validate: async (val) => {
-                        if (!val.trim())
-                            return 'Owner is required';
-                        // Validate owner exists on the platform
-                        if (this.githubToken) {
-                            const result = await provider.validateOwner(val, this.githubToken);
-                            if (!result.valid) {
-                                return result.error || `Invalid ${provider.config.name} owner`;
-                            }
-                        }
-                        return true;
-                    }
-                });
-                parentAnswers = {
-                    parentName: parentNameAnswer,
-                    owner: ownerForLocalAnswer
-                };
-                // Set defaults for local parent
-                parentAnswers.description = 'Local parent folder (not synced to GitHub)';
-                parentAnswers.createOnGitHub = false; // Never create GitHub repo for local parent
-            }
-            else {
-                // GitHub parent: First ask if using existing or creating new
-                const parentChoice = await select({
-                    message: 'Parent repository setup:',
-                    choices: [
-                        {
-                            name: `${chalk.green('Use existing parent repository')}\n${chalk.gray('Connect to an existing GitHub repo that already has .specweave/ structure')}`,
-                            value: 'existing'
-                        },
-                        {
-                            name: `${chalk.blue('Create new parent repository')}\n${chalk.gray('Create a new GitHub repo for specs, docs, and architecture')}`,
-                            value: 'new'
-                        }
-                    ],
-                    default: 'new'
-                });
-                if (parentChoice === 'existing') {
-                    // Using existing parent repository
-                    console.log(chalk.cyan('\n📋 Existing Parent Repository\n'));
-                    // Ask for owner first
-                    const existingOwner = await input({
-                        message: `${provider.config.name} owner/organization:`,
-                        validate: async (val) => {
-                            if (!val.trim())
-                                return 'Owner is required';
-                            // Validate owner exists on the platform
-                            if (this.githubToken) {
-                                const result = await provider.validateOwner(val, this.githubToken);
-                                if (!result.valid) {
-                                    return result.error || `Invalid ${provider.config.name} owner`;
-                                }
-                            }
-                            return true;
-                        }
-                    });
-                    const ownerPrompt = { owner: existingOwner };
-                    // Ask for existing repo name
-                    const existingParentName = await input({
-                        message: 'Existing parent repository name:',
-                        default: `${path.basename(this.projectPath)}-parent`,
-                        validate: async (val) => {
-                            if (!val.trim())
-                                return 'Repository name is required';
-                            // Validate repository EXISTS on the platform
-                            if (this.githubToken && ownerPrompt.owner) {
-                                const result = await provider.validateRepository(ownerPrompt.owner, val, this.githubToken);
-                                if (!result.exists) {
-                                    return `Repository ${ownerPrompt.owner}/${val} not found on ${provider.config.name}. Please check the name or choose 'Create new'.`;
-                                }
-                            }
-                            return true;
-                        }
-                    });
-                    const repoPrompt = { parentName: existingParentName };
-                    // Fetch description and visibility from GitHub API (or use defaults)
-                    let description = 'SpecWeave parent repository - specs, docs, and architecture';
-                    let existingVisibility = 'private';
-                    if (this.githubToken) {
-                        try {
-                            const response = await fetch(`https://api.github.com/repos/${ownerPrompt.owner}/${repoPrompt.parentName}`, {
-                                headers: {
-                                    'Authorization': `Bearer ${this.githubToken}`,
-                                    'Accept': 'application/vnd.github+json'
-                                }
-                            });
-                            if (response.ok) {
-                                const data = await response.json();
-                                description = data.description || description;
-                                existingVisibility = data.private ? 'private' : 'public';
-                            }
-                        }
-                        catch {
-                            // Use defaults if fetch fails
-                        }
-                    }
-                    parentAnswers = {
-                        owner: ownerPrompt.owner,
-                        parentName: repoPrompt.parentName,
-                        description: description,
-                        createOnGitHub: false, // Don't create, it already exists!
-                        visibility: existingVisibility // Use existing visibility from GitHub
-                    };
-                    console.log(chalk.green(`\n✓ Using existing repository: ${ownerPrompt.owner}/${repoPrompt.parentName}\n`));
-                }
-                else {
-                    // Creating new parent repository
-                    console.log(chalk.cyan('\n✨ New Parent Repository\n'));
-                    // Ask for owner (separate prompt to avoid validator issues)
-                    const newOwner = await input({
-                        message: `${provider.config.name} owner/organization for ALL repos:`,
-                        validate: async (val) => {
-                            if (!val.trim())
-                                return 'Owner is required';
-                            // Validate owner exists on the platform
-                            if (this.githubToken) {
-                                const result = await provider.validateOwner(val, this.githubToken);
-                                if (!result.valid) {
-                                    return result.error || `Invalid ${provider.config.name} owner`;
-                                }
-                            }
-                            return true;
-                        }
-                    });
-                    const ownerPrompt = { owner: newOwner };
-                    // Now ask remaining questions, using the owner value
-                    const newParentName = await input({
-                        message: 'Parent repository name:',
-                        default: `${path.basename(this.projectPath)}-parent`,
-                        validate: async (val) => {
-                            if (!val.trim())
-                                return 'Repository name is required';
-                            // Validate repository DOESN'T exist
-                            if (this.githubToken && ownerPrompt.owner) {
-                                const result = await provider.validateRepository(ownerPrompt.owner, val, this.githubToken);
-                                if (result.exists) {
-                                    return `Repository ${ownerPrompt.owner}/${val} already exists at ${result.url}. Please choose 'Use existing' or pick a different name.`;
-                                }
-                            }
-                            return true;
-                        }
-                    });
-                    const newParentDesc = await input({
-                        message: 'Parent repository description:',
-                        default: 'SpecWeave parent repository - specs, docs, and architecture'
-                    });
-                    const createParentOnGitHub = await confirm({
-                        message: 'Create parent repository on GitHub?',
-                        default: true
-                    });
-                    // Merge the answers
-                    parentAnswers = {
-                        ...ownerPrompt,
-                        parentName: newParentName,
-                        description: newParentDesc,
-                        createOnGitHub: createParentOnGitHub
-                    };
-                }
-            }
-            // Ask about visibility for parent repo (only if creating NEW repo on GitHub)
-            let parentVisibility = 'private';
-            if (!isLocalParent && parentAnswers.createOnGitHub) {
-                // Only prompt for visibility when creating a NEW repository
-                const parentVisibilityPrompt = getVisibilityPrompt(parentAnswers.parentName);
-                parentVisibility = await select({
-                    message: parentVisibilityPrompt.question,
-                    choices: parentVisibilityPrompt.options.map(opt => ({
-                        name: `${opt.label}\n${chalk.gray(opt.description)}`,
-                        value: opt.value
-                    })),
-                    default: parentVisibilityPrompt.default
-                });
-            }
-            else if (!isLocalParent && parentAnswers.visibility) {
-                // Use existing repository's visibility (fetched from GitHub API)
-                parentVisibility = parentAnswers.visibility;
-            }
-            config.parentRepo = {
-                name: parentAnswers.parentName,
-                owner: parentAnswers.owner,
-                description: parentAnswers.description,
-                visibility: parentVisibility,
-                createOnGitHub: parentAnswers.createOnGitHub
-            };
-            // Save state: parent repo configured
-            await this.saveSetupState({
-                version: '1.0.0',
-                architecture: useParent ? 'parent' : 'multi-repo',
-                parentRepo: config.parentRepo,
-                repos: [],
-                currentStep: 'parent-repo-configured',
-                timestamp: new Date().toISOString(),
-                envCreated: false
-            });
-        }
-        // Step 4: Repository count and discovery (skip count question if using bulk discovery)
-        let repoCount;
-        let bulkDiscoveryStrategy = discoveryStrategy === 'bulk-discovery' ? 'pattern' : 'manual';
-        if (discoveryStrategy === 'bulk-discovery' && discoveredRepos.length > 0) {
-            // Bulk discovery: repos already discovered, skip count question
-            repoCount = discoveredRepos.length;
-            console.log(chalk.green(`\n✓ Total repositories: ${repoCount + 1} (1 parent + ${repoCount} implementation)\n`));
-        }
-        else {
-            // Manual entry: ask for count
-            // Auto-detect existing folders
-            const hints = await detectRepositoryHints(this.projectPath);
-            if (hints.detectedFolders.length > 0) {
-                console.log(chalk.green(`\n✓ Detected ${hints.detectedFolders.length} service folder(s):`));
-                hints.detectedFolders.forEach(f => console.log(chalk.gray(`  • ${f}`)));
-                console.log('');
-            }
-            // Show repository count clarification BEFORE asking
-            if (useParent && config.parentRepo) {
-                console.log(chalk.cyan('\n📊 Repository Count\n'));
-                console.log(chalk.gray('You will create:'));
-                if (isLocalParent) {
-                    console.log(chalk.white('  • 1 parent FOLDER (local only, .specweave/ gitignored)'));
-                    console.log(chalk.white('  • N implementation repositories (your services/apps on GitHub)'));
-                }
-                else {
-                    console.log(chalk.white('  • 1 parent repository (specs, docs, increments)'));
-                    console.log(chalk.white('  • N implementation repositories (your services/apps)'));
-                }
-                console.log(chalk.gray('\nNext question asks for: IMPLEMENTATION repositories ONLY (not counting parent)\n'));
-            }
-            // Ask how many implementation repositories
-            const repoCountAnswer = await number({
-                message: useParent
-                    ? '📦 How many IMPLEMENTATION repositories? (not counting parent)'
-                    : 'How many repositories?',
-                default: hints.suggestedCount, // Use auto-detected count
-                validate: (val) => {
-                    if (val === undefined || val < 1)
-                        return useParent
-                            ? 'Need at least 1 implementation repository'
-                            : 'Need at least 2 repositories';
-                    if (val > 10)
-                        return 'Maximum 10 repositories supported';
-                    return true;
-                }
-            });
-            repoCount = repoCountAnswer ?? hints.suggestedCount;
-            // Show summary AFTER for confirmation
-            if (useParent && config.parentRepo) {
-                if (isLocalParent) {
-                    console.log(chalk.green(`\n✓ Total repositories to create: ${repoCount} implementation repos`));
-                    console.log(chalk.gray(`  (Parent folder is local only, not counted)\n`));
-                }
-                else {
-                    const totalRepos = 1 + repoCount;
-                    console.log(chalk.green(`\n✓ Total repositories to create: ${totalRepos} (1 parent + ${repoCount} implementation)\n`));
-                }
-            }
-            // Bulk repository discovery for manual flow (old behavior)
-            if (this.githubToken && config.parentRepo && discoveryStrategy === 'manual') {
-                const octokit = new Octokit({ auth: this.githubToken });
-                const owner = config.parentRepo.owner;
-                const isOrg = await provider.isOrganization(owner, this.githubToken);
-                // Retry loop for pattern adjustment
-                let discoveryResult = null;
-                while (discoveryResult === null) {
-                    discoveryResult = await discoverRepositories(octokit, owner, isOrg, repoCount);
-                    // If null, user selected "go back and adjust pattern", loop will retry
-                    // If user selected "manual", discoveryResult will be { repositories: [], strategy: 'manual' }
-                }
-                if (discoveryResult) {
-                    bulkDiscoveryStrategy = discoveryResult.strategy;
-                    if (discoveryResult.strategy !== 'manual') {
-                        discoveredRepos = discoveryResult.repositories;
-                        // Update repoCount to match discovered repos
-                        if (discoveredRepos.length !== repoCount) {
-                            console.log(chalk.yellow(`\n📝 Adjusting repository count from ${repoCount} to ${discoveredRepos.length} (based on discovery)\n`));
-                            repoCount = discoveredRepos.length;
-                        }
-                    }
-                }
-            }
-        }
-        // Configure each repository
-        console.log(chalk.cyan('\n📦 Configure Each Repository:\n'));
-        const usedIds = new Set();
-        const configuredRepoNames = []; // Track configured repo names for smart ID generation
-        for (let i = 0; i < repoCount; i++) {
-            const discoveredRepo = discoveredRepos[i]; // May be undefined if manual
-            const isDiscovered = bulkDiscoveryStrategy !== 'manual' && discoveredRepo;
-            console.log(chalk.white(`\nRepository ${i + 1} of ${repoCount}:`));
-            // Smart suggestion for ALL repos (not just first one!)
-            const projectName = path.basename(this.projectPath);
-            const suggestedName = isDiscovered ? discoveredRepo.name : suggestRepoName(projectName, i, repoCount);
-            // If discovered, auto-use without confirmation (repos exist on GitHub)
-            if (isDiscovered) {
-                // Use normalized repo name as ID (repo names are unique in GitHub)
-                const repoId = normalizeRepoName(discoveredRepo.name);
-                console.log(chalk.green(`   ✓ Using: ${chalk.bold(discoveredRepo.name)} ${chalk.gray(`(id: ${repoId})`)}`));
-                usedIds.add(repoId);
-                configuredRepoNames.push(discoveredRepo.name);
-                config.repositories.push({
-                    id: repoId,
-                    name: discoveredRepo.name,
-                    owner: discoveredRepo.owner,
-                    description: discoveredRepo.description || `${discoveredRepo.name} service`,
-                    path: discoveredRepo.name,
-                    visibility: discoveredRepo.private ? 'private' : 'public',
-                    createOnGitHub: false,
-                    isNested: useParent
-                });
-                continue;
-            }
-            // Manual entry (original behavior)
-            const repoName = await input({
-                message: 'Repository name:',
-                default: suggestedName,
-                validate: async (val) => {
-                    if (!val.trim())
-                        return 'Repository name is required';
-                    // Validate repository doesn't exist (skip for discovered repos)
-                    if (!isDiscovered && this.githubToken && config.parentRepo) {
-                        const result = await provider.validateRepository(config.parentRepo.owner, val, this.githubToken);
-                        if (result.exists) {
-                            return `Repository ${config.parentRepo.owner}/${val} already exists at ${result.url}`;
-                        }
-                    }
-                    return true;
-                }
-            });
-            const repoDescription = await input({
-                message: 'Repository description:',
-                default: `${path.basename(repoName)} service`
-            });
-            // Skip "Create on GitHub?" for discovered repos - they already exist!
-            let repoCreateOnGitHub = false;
-            if (!isDiscovered) {
-                repoCreateOnGitHub = await confirm({
-                    message: 'Create this repository on GitHub?',
-                    default: true
-                });
-            }
-            const repoAnswers = {
-                name: repoName,
-                description: repoDescription,
-                createOnGitHub: repoCreateOnGitHub
-            };
-            // Use normalized repo name as ID (repo names are unique)
-            const id = normalizeRepoName(repoAnswers.name);
-            console.log(chalk.green(`   ✓ Repository ID: ${chalk.bold(id)}`));
-            usedIds.add(id);
-            configuredRepoNames.push(repoAnswers.name);
-            // Ask about visibility only if creating a new repository
-            let visibility = 'private';
-            if (repoAnswers.createOnGitHub) {
-                const visibilityPrompt = getVisibilityPrompt(repoAnswers.name);
-                visibility = await select({
-                    message: visibilityPrompt.question,
-                    choices: visibilityPrompt.options.map(opt => ({
-                        name: `${opt.label}\n${chalk.gray(opt.description)}`,
-                        value: opt.value
-                    })),
-                    default: visibilityPrompt.default
-                });
-            }
-            config.repositories.push({
-                id: id,
-                name: repoAnswers.name,
-                owner: config.parentRepo?.owner || '',
-                description: repoAnswers.description,
-                path: repoAnswers.name, // Use full repo name as folder (not short ID)
-                visibility: visibility,
-                createOnGitHub: repoAnswers.createOnGitHub,
-                isNested: useParent
-            });
-            // Save state after each repo
-            await this.saveSetupState({
-                version: '1.0.0',
-                architecture: useParent ? 'parent' : 'multi-repo',
-                parentRepo: config.parentRepo,
-                repos: config.repositories.map(r => ({
-                    id: r.id,
-                    repo: r.name,
-                    owner: r.owner,
-                    path: r.path,
-                    visibility: r.visibility,
-                    displayName: r.name,
-                    created: false
-                })),
-                currentStep: `repo-${i + 1}-configured`,
-                timestamp: new Date().toISOString(),
-                envCreated: false
-            });
-        }
-        return config;
-    }
-    /**
-     * Save setup state for Ctrl+C recovery
-     */
-    async saveSetupState(state) {
-        try {
-            await this.stateManager.saveState(state);
-        }
-        catch (error) {
-            console.warn(chalk.yellow(`⚠️  Failed to save setup state: ${error.message}`));
-        }
-    }
     /**
      * Configure monorepo
      */
@@ -1015,7 +416,7 @@ export class RepoStructureManager {
                 }, this.githubToken);
                 created.push(`${config.parentRepo.owner}/${config.parentRepo.name}`);
                 // Save state: parent repo created
-                await this.saveSetupState({
+                await this.stateManager.saveState({
                     version: '1.0.0',
                     architecture: config.architecture,
                     parentRepo: { ...config.parentRepo, url: config.provider.getRemoteUrl(config.parentRepo.owner, config.parentRepo.name, config.urlType) },
@@ -1083,7 +484,7 @@ export class RepoStructureManager {
             console.log(chalk.gray('   TIP: gh CLI auth is recommended over tokens'));
             console.log(chalk.yellow('   ⚠️  DO NOT commit .env to git (contains secrets!)'));
             // Save state: env created
-            await this.saveSetupState({
+            await this.stateManager.saveState({
                 version: '1.0.0',
                 architecture: config.architecture,
                 parentRepo: config.parentRepo,
@@ -1192,200 +593,19 @@ export class RepoStructureManager {
         }
         return false;
     }
-    /**
-     * Check if a repository exists on GitHub
-     */
-    async repositoryExistsOnGitHub(owner, repo) {
-        if (!this.githubToken) {
-            return false;
-        }
-        try {
-            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
-                headers: {
-                    'Authorization': `Bearer ${this.githubToken}`,
-                    'Accept': 'application/vnd.github+json'
-                }
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Clone or initialize a repository
-     * If the repo exists on the platform, clone it; otherwise, init + add remote
-     */
-    async cloneOrInitRepository(repoPath, owner, name, createOnGitHub, urlType = 'ssh', provider) {
-        // If .git already exists, skip
-        if (existsSync(path.join(repoPath, '.git'))) {
-            return;
-        }
-        const remoteUrl = provider.getRemoteUrl(owner, name, urlType);
-        // Check if repository exists on GitHub
-        const repoExists = await this.repositoryExistsOnGitHub(owner, name);
-        if (repoExists) {
-            // Repository exists - clone it
-            console.log(chalk.gray(`   → Cloning existing repository from GitHub...`));
-            try {
-                // Remove directory if it exists and is empty
-                if (existsSync(repoPath)) {
-                    const files = require('fs').readdirSync(repoPath);
-                    if (files.length === 0) {
-                        require('fs').rmdirSync(repoPath);
-                    }
-                }
-                // Clone the repository
-                const parentDir = path.dirname(repoPath);
-                const repoName = path.basename(repoPath);
-                execFileNoThrowSync('git', ['clone', remoteUrl, repoName], { cwd: parentDir });
-                console.log(chalk.green(`   ✓ Cloned ${owner}/${name}`));
-            }
-            catch (error) {
-                console.log(chalk.yellow(`   ⚠️  Clone failed: ${error.message}`));
-                console.log(chalk.gray(`   → Falling back to init + remote`));
-                // Fallback: init + add remote
-                if (!existsSync(repoPath)) {
-                    mkdirSync(repoPath, { recursive: true });
-                }
-                execFileNoThrowSync('git', ['init'], { cwd: repoPath });
-                execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: repoPath });
-            }
-        }
-        else {
-            // Repository doesn't exist - init + add remote
-            if (!createOnGitHub) {
-                console.log(chalk.gray(`   → Repository will be created later (skipping for now)`));
-                return;
-            }
-            console.log(chalk.gray(`   → Initializing empty git repository...`));
-            if (!existsSync(repoPath)) {
-                mkdirSync(repoPath, { recursive: true });
-            }
-            execFileNoThrowSync('git', ['init'], { cwd: repoPath });
-            execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: repoPath });
-            console.log(chalk.green(`   ✓ Initialized ${owner}/${name}`));
-        }
-    }
     /**
      * Initialize local git repositories
+     * Delegates to extracted repo-initializer module
      */
     async initializeLocalRepos(config) {
-        const spinner = ora('Initializing local repositories...').start();
-        // Create directory structure based on architecture
-        if (config.architecture === 'parent') {
-            // Parent repo approach: ROOT-LEVEL cloning (not services/!)
-            // Initialize parent repo at root
-            if (!existsSync(path.join(this.projectPath, '.git'))) {
-                execFileNoThrowSync('git', ['init'], { cwd: this.projectPath });
-                if (config.parentRepo) {
-                    const remoteUrl = config.provider.getRemoteUrl(config.parentRepo.owner, config.parentRepo.name, config.urlType);
-                    execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: this.projectPath });
-                }
-            }
-            // Initialize implementation repos at ROOT LEVEL
-            for (const repo of config.repositories) {
-                const repoPath = path.join(this.projectPath, repo.path);
-                // Clone or initialize repository
-                await this.cloneOrInitRepository(repoPath, repo.owner, repo.name, repo.createOnGitHub, config.urlType, config.provider);
-                // Create basic structure (only if repo was just initialized, not cloned)
-                if (!repo.createOnGitHub || !await this.repositoryExistsOnGitHub(repo.owner, repo.name)) {
-                    this.createBasicRepoStructure(repoPath, repo.id);
-                }
-            }
-        }
-        else if (config.architecture === 'multi-repo') {
-            // Standard multi-repo: repos as subdirectories
-            for (const repo of config.repositories) {
-                const repoPath = path.join(this.projectPath, repo.path);
-                // Clone or initialize repository
-                await this.cloneOrInitRepository(repoPath, repo.owner, repo.name, repo.createOnGitHub, config.urlType, config.provider);
-                // Create basic structure (only if repo was just initialized, not cloned)
-                if (!repo.createOnGitHub || !await this.repositoryExistsOnGitHub(repo.owner, repo.name)) {
-                    this.createBasicRepoStructure(repoPath, repo.id);
-                }
-            }
-        }
-        else {
-            // Single repo or monorepo
-            if (!existsSync(path.join(this.projectPath, '.git'))) {
-                execFileNoThrowSync('git', ['init'], { cwd: this.projectPath });
-                const repo = config.repositories[0];
-                if (repo) {
-                    const remoteUrl = config.provider.getRemoteUrl(repo.owner, repo.name, config.urlType);
-                    execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: this.projectPath });
-                }
-            }
-            // For monorepo, create project directories
-            if (config.architecture === 'monorepo' && config.monorepoProjects) {
-                for (const project of config.monorepoProjects) {
-                    const projectPath = path.join(this.projectPath, 'packages', project);
-                    if (!existsSync(projectPath)) {
-                        mkdirSync(projectPath, { recursive: true });
-                    }
-                    this.createBasicRepoStructure(projectPath, project);
-                }
-            }
-        }
-        spinner.succeed('Local repositories initialized');
-    }
-    /**
-     * Create basic structure for a repository/project
-     *
-     * NOTE: Only creates src/ and tests/ folders for nested projects.
-     * Documentation lives in .specweave/docs/internal/specs/{project-id}/ (source of truth)
-     */
-    createBasicRepoStructure(repoPath, projectId) {
-        // Create basic directories (NO docs/ - documentation lives in .specweave/)
-        const dirs = ['src', 'tests'];
-        for (const dir of dirs) {
-            const dirPath = path.join(repoPath, dir);
-            if (!existsSync(dirPath)) {
-                mkdirSync(dirPath, { recursive: true });
-            }
-        }
-        // Create README.md
-        const readmePath = path.join(repoPath, 'README.md');
-        if (!existsSync(readmePath)) {
-            const readmeContent = `# ${projectId}\n\n${projectId} service/component.\n\nPart of SpecWeave multi-repository project.\n`;
-            writeFileSync(readmePath, readmeContent);
-        }
-        // Create .gitignore
-        const gitignorePath = path.join(repoPath, '.gitignore');
-        if (!existsSync(gitignorePath)) {
-            const gitignoreContent = `node_modules/\ndist/\n.env\n.DS_Store\n*.log\n`;
-            writeFileSync(gitignorePath, gitignoreContent);
-        }
+        return initLocalRepos(config, this.projectPath, this.githubToken);
     }
     /**
-     * Create SpecWeave project structure (simplified - ONLY specs folders)
-     *
-     * NOTE: As of v0.X.X (increment 0026), we ONLY create specs/ folders.
-     * No modules/, team/, architecture/, legacy/ folders.
+     * Create SpecWeave project structure
+     * Delegates to extracted repo-initializer module
      */
     async createSpecWeaveStructure(config) {
-        const specweavePath = path.join(this.projectPath, '.specweave');
-        // Create project-specific spec folders (ONLY specs/, no nested folders)
-        if (config.architecture === 'monorepo' && config.monorepoProjects) {
-            // Monorepo: create specs folder for each project
-            for (const project of config.monorepoProjects) {
-                const projectSpecPath = path.join(specweavePath, 'docs', 'internal', 'specs', project.toLowerCase());
-                if (!existsSync(projectSpecPath)) {
-                    mkdirSync(projectSpecPath, { recursive: true });
-                }
-                console.log(chalk.gray(`   ✓ Created project structure: ${project}`));
-            }
-        }
-        else if (config.architecture === 'multi-repo' || config.architecture === 'parent') {
-            // Multi-repo: create specs folder for each repository
-            for (const repo of config.repositories) {
-                const projectSpecPath = path.join(specweavePath, 'docs', 'internal', 'specs', repo.id);
-                if (!existsSync(projectSpecPath)) {
-                    mkdirSync(projectSpecPath, { recursive: true });
-                }
-                console.log(chalk.gray(`   ✓ Created project structure: ${repo.path}`));
-            }
-        }
+        return createSpecWeaveStruct(config, this.projectPath);
     }
 }
 //# sourceMappingURL=repo-structure-manager.js.map