specweave 0.24.6 → 0.24.9

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

@@ -23,23 +23,29 @@ import { execSync } from 'child_process';
 import { execFileNoThrowSync } from '../../utils/execFileNoThrow.js';
 import { generateRepoIdSmart, ensureUniqueId, validateRepoId, suggestRepoName } from './repo-id-generator.js';
 import { SetupStateManager } from './setup-state-manager.js';
-import { validateRepository, validateOwner } from './github-validator.js';
 import { generateEnvFile } from '../../utils/env-file-generator.js';
 import { generateSetupSummary } from './setup-summary.js';
-import { getArchitecturePrompt, getParentRepoBenefits, getVisibilityPrompt } from './prompt-consolidator.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 { initializeProviders } from './providers/index.js';
+import { getPlatformRegistry } from './platform-registry.js';
+import { getPlatformSelectionPrompt } from './prompt-consolidator.js';
 export class RepoStructureManager {
     constructor(projectPath, githubToken) {
         this.projectPath = projectPath;
         this.githubToken = githubToken;
         this.stateManager = new SetupStateManager(projectPath);
+        // Initialize Git providers on instantiation
+        initializeProviders();
     }
     /**
      * Prompt user for repository structure decisions
+     *
+     * @param preSelectedArchitecture - Optional pre-selected architecture to skip duplicate prompts
      */
-    async promptStructure() {
+    async promptStructure(preSelectedArchitecture) {
         console.log(chalk.cyan.bold('\n🏗️  Repository Architecture Setup\n'));
         console.log(chalk.gray('Let\'s configure your repository structure for optimal organization.\n'));
         // Check for resumed setup
@@ -62,27 +68,76 @@ export class RepoStructureManager {
                 await this.stateManager.deleteState();
             }
         }
-        // Step 1: Ask about architecture type using consolidator
-        const promptData = getArchitecturePrompt();
-        const { architecture } = await inquirer.prompt([{
+        // Step 1: Ask about architecture type using consolidator (SKIP if pre-selected)
+        let architecture;
+        if (preSelectedArchitecture) {
+            // Architecture already selected - skip duplicate prompt
+            architecture = preSelectedArchitecture;
+            console.log(chalk.green(`✓ Architecture: ${this.formatArchitectureForDisplay(architecture)}\n`));
+        }
+        else {
+            // Ask user for architecture choice
+            const promptData = getArchitecturePrompt();
+            const result = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'architecture',
+                    message: promptData.question,
+                    choices: promptData.options.map(opt => ({
+                        name: `${opt.label}\n${chalk.gray(opt.description)}\n${chalk.dim(opt.example)}`,
+                        value: opt.value,
+                        short: opt.label
+                    })),
+                    default: 'single'
+                }]);
+            architecture = result.architecture;
+        }
+        // Step 2: Ask about Git hosting platform
+        const registry = getPlatformRegistry();
+        const platformOptions = registry.getPlatformOptions(true); // Include unsupported platforms
+        const platformPromptData = getPlatformSelectionPrompt();
+        console.log(chalk.cyan('\n' + platformPromptData.message));
+        const { platform } = await inquirer.prompt([{
+                type: 'list',
+                name: 'platform',
+                message: platformPromptData.question,
+                choices: platformOptions.map(opt => ({
+                    name: opt.disabled
+                        ? `${opt.name}\n${chalk.gray(opt.description)}\n${chalk.yellow('⚠️  ' + opt.disabled)}`
+                        : `${opt.name}\n${chalk.gray(opt.description)}`,
+                    value: opt.value,
+                    short: opt.name,
+                    disabled: opt.disabled ? opt.disabled : false
+                })),
+                default: 'github'
+            }]);
+        // Get provider instance
+        const provider = registry.getProvider(platform);
+        if (!provider) {
+            throw new Error(`Platform ${platform} is not available. This should not happen!`);
+        }
+        console.log(chalk.green(`\n✓ Using ${provider.config.name} as Git hosting platform\n`));
+        // Step 3: Ask about Git remote URL format (SSH vs HTTPS)
+        const urlTypePromptData = getUrlTypePrompt();
+        const { urlType } = await inquirer.prompt([{
                 type: 'list',
-                name: 'architecture',
-                message: promptData.question,
-                choices: promptData.options.map(opt => ({
-                    name: `${opt.label}\n${chalk.gray(opt.description)}\n${chalk.dim(opt.example)}`,
+                name: 'urlType',
+                message: urlTypePromptData.question,
+                choices: urlTypePromptData.options.map(opt => ({
+                    name: `${opt.label}\n${chalk.gray(opt.description)}`,
                     value: opt.value,
                     short: opt.label
                 })),
-                default: 'single'
+                default: urlTypePromptData.default
             }]);
+        console.log(chalk.green(`\n✓ Using ${urlType.toUpperCase()} remote URLs\n`));
         // Map ArchitectureChoice to internal architecture
         const mappedArch = this.mapArchitectureChoice(architecture);
         switch (mappedArch) {
             case 'single':
-                return this.configureSingleRepo();
+                return this.configureSingleRepo(urlType, platform, provider);
             case 'parent':
                 // GitHub parent repo (pushed to GitHub)
-                return this.configureMultiRepo(true, false);
+                return this.configureMultiRepo(true, false, urlType, platform, provider);
             default:
                 throw new Error(`Unknown architecture: ${architecture}`);
         }
@@ -100,13 +155,38 @@ export class RepoStructureManager {
                 return 'single';
         }
     }
+    /**
+     * Format architecture choice for display
+     *
+     * @param choice - Architecture choice
+     * @returns Human-readable format
+     */
+    formatArchitectureForDisplay(choice) {
+        switch (choice) {
+            case 'single':
+                return 'Single repository';
+            case 'github-parent':
+                return 'Parent repo + nested repos (GitHub)';
+            default:
+                return choice;
+        }
+    }
     /**
      * Resume setup from saved state
      */
     async resumeSetup(state) {
+        // Default to GitHub platform for resumed setups (backward compatibility)
+        const registry = getPlatformRegistry();
+        const provider = registry.getProvider('github');
+        if (!provider) {
+            throw new Error('GitHub provider not available. This should not happen!');
+        }
         // Convert saved state back to config format
         const config = {
             architecture: state.architecture,
+            urlType: 'ssh', // Default to SSH for resumed setups
+            platform: 'github', // Default to GitHub for backward compatibility
+            provider: provider,
             parentRepo: state.parentRepo,
             repositories: state.repos.map(r => ({
                 id: r.id,
@@ -126,7 +206,7 @@ export class RepoStructureManager {
     /**
      * Configure single repository
      */
-    async configureSingleRepo() {
+    async configureSingleRepo(urlType = 'ssh', platform = 'github', provider) {
         console.log(chalk.cyan('\n📦 Single Repository Configuration\n'));
         // Check if repo already exists
         const hasGit = existsSync(path.join(this.projectPath, '.git'));
@@ -172,6 +252,9 @@ export class RepoStructureManager {
                         }
                         return {
                             architecture: 'single',
+                            urlType,
+                            platform,
+                            provider,
                             repositories: [{
                                     id: 'main',
                                     name: repo,
@@ -237,6 +320,9 @@ export class RepoStructureManager {
         }
         return {
             architecture: 'single',
+            urlType,
+            platform,
+            provider,
             repositories: [{
                     id: 'main',
                     name: answers.repo,
@@ -253,12 +339,15 @@ 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) {
+    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
@@ -268,6 +357,9 @@ export class RepoStructureManager {
         }
         const config = {
             architecture: useParent ? 'parent' : 'multi-repo',
+            urlType,
+            platform,
+            provider,
             repositories: []
         };
         // Save state: architecture selected
@@ -280,8 +372,155 @@ export class RepoStructureManager {
             timestamp: new Date().toISOString(),
             envCreated: false
         });
-        // Configure parent repository if using that approach
-        if (useParent) {
+        // ========== 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 Configuration\n'));
+            console.log(chalk.gray('You can discover repositories automatically or enter them manually.\n'));
+            const { configMethod } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'configMethod',
+                    message: 'How do you want to configure these repositories?',
+                    choices: [
+                        {
+                            name: `${chalk.bold('Manual entry')} - Enter parent and each repository one by one ${chalk.gray('(full control)')}`,
+                            value: 'manual'
+                        },
+                        {
+                            name: `${chalk.bold('Pattern matching')} - Discover repositories, then select parent ${chalk.gray('(faster for many repos)')}`,
+                            value: 'pattern-first'
+                        }
+                    ],
+                    default: 'manual'
+                }
+            ]);
+            discoveryStrategy = configMethod;
+        }
+        // Step 2: If pattern/all, discover repos FIRST, then ask which is parent
+        if (discoveryStrategy === 'pattern-first') {
+            // Get owner FIRST (needed for discovery)
+            console.log(chalk.cyan('\n👤 Repository Owner\n'));
+            const ownerPrompt = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'owner',
+                    message: `${provider.config.name} owner/organization:`,
+                    validate: async (input) => {
+                        if (!input.trim())
+                            return 'Owner is required';
+                        // Validate owner exists on the platform
+                        if (this.githubToken) {
+                            const result = await provider.validateOwner(input, this.githubToken);
+                            if (!result.valid) {
+                                return result.error || `Invalid ${provider.config.name} owner`;
+                            }
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            owner = ownerPrompt.owner;
+            // 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) {
+                discoveryResult = await discoverRepositories(octokit, owner, isOrg, 0); // Pass 0, we'll count later
+                // 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 inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'parentSelection',
+                        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
@@ -302,15 +541,15 @@ export class RepoStructureManager {
                     {
                         type: 'input',
                         name: 'owner',
-                        message: 'GitHub owner/organization for IMPLEMENTATION repos:',
+                        message: `${provider.config.name} owner/organization for IMPLEMENTATION repos:`,
                         validate: async (input) => {
                             if (!input.trim())
                                 return 'Owner is required';
-                            // Validate owner exists on GitHub
+                            // Validate owner exists on the platform
                             if (this.githubToken) {
-                                const result = await validateOwner(input, this.githubToken);
+                                const result = await provider.validateOwner(input, this.githubToken);
                                 if (!result.valid) {
-                                    return result.error || 'Invalid GitHub owner';
+                                    return result.error || `Invalid ${provider.config.name} owner`;
                                 }
                             }
                             return true;
@@ -351,15 +590,15 @@ export class RepoStructureManager {
                         {
                             type: 'input',
                             name: 'owner',
-                            message: 'GitHub owner/organization:',
+                            message: `${provider.config.name} owner/organization:`,
                             validate: async (input) => {
                                 if (!input.trim())
                                     return 'Owner is required';
-                                // Validate owner exists on GitHub
+                                // Validate owner exists on the platform
                                 if (this.githubToken) {
-                                    const result = await validateOwner(input, this.githubToken);
+                                    const result = await provider.validateOwner(input, this.githubToken);
                                     if (!result.valid) {
-                                        return result.error || 'Invalid GitHub owner';
+                                        return result.error || `Invalid ${provider.config.name} owner`;
                                     }
                                 }
                                 return true;
@@ -376,11 +615,11 @@ export class RepoStructureManager {
                             validate: async (input) => {
                                 if (!input.trim())
                                     return 'Repository name is required';
-                                // Validate repository EXISTS on GitHub
+                                // Validate repository EXISTS on the platform
                                 if (this.githubToken && ownerPrompt.owner) {
-                                    const result = await validateRepository(ownerPrompt.owner, input, this.githubToken);
+                                    const result = await provider.validateRepository(ownerPrompt.owner, input, this.githubToken);
                                     if (!result.exists) {
-                                        return `Repository ${ownerPrompt.owner}/${input} not found on GitHub. Please check the name or choose 'Create new'.`;
+                                        return `Repository ${ownerPrompt.owner}/${input} not found on ${provider.config.name}. Please check the name or choose 'Create new'.`;
                                     }
                                 }
                                 return true;
@@ -425,15 +664,15 @@ export class RepoStructureManager {
                         {
                             type: 'input',
                             name: 'owner',
-                            message: 'GitHub owner/organization for ALL repos:',
+                            message: `${provider.config.name} owner/organization for ALL repos:`,
                             validate: async (input) => {
                                 if (!input.trim())
                                     return 'Owner is required';
-                                // Validate owner exists on GitHub
+                                // Validate owner exists on the platform
                                 if (this.githubToken) {
-                                    const result = await validateOwner(input, this.githubToken);
+                                    const result = await provider.validateOwner(input, this.githubToken);
                                     if (!result.valid) {
-                                        return result.error || 'Invalid GitHub owner';
+                                        return result.error || `Invalid ${provider.config.name} owner`;
                                     }
                                 }
                                 return true;
@@ -452,7 +691,7 @@ export class RepoStructureManager {
                                     return 'Repository name is required';
                                 // Validate repository DOESN'T exist
                                 if (this.githubToken && ownerPrompt.owner) {
-                                    const result = await validateRepository(ownerPrompt.owner, input, this.githubToken);
+                                    const result = await provider.validateRepository(ownerPrompt.owner, input, this.githubToken);
                                     if (result.exists) {
                                         return `Repository ${ownerPrompt.owner}/${input} already exists at ${result.url}. Please choose 'Use existing' or pick a different name.`;
                                     }
@@ -517,73 +756,88 @@ export class RepoStructureManager {
                 envCreated: false
             });
         }
-        // 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('');
+        // Step 4: Repository count and discovery (skip count question if using pattern-first)
+        let repoCount;
+        let bulkDiscoveryStrategy = discoveryStrategy === 'pattern-first' ? 'pattern' : 'manual';
+        if (discoveryStrategy === 'pattern-first' && discoveredRepos.length > 0) {
+            // Pattern discovery: repos already discovered, skip count question
+            repoCount = discoveredRepos.length;
+            console.log(chalk.green(`\n✓ Total repositories: ${repoCount + 1} (1 parent + ${repoCount} implementation)\n`));
         }
-        // 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)'));
+        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('');
             }
-            console.log(chalk.gray('\nNext question asks for: IMPLEMENTATION repositories ONLY (not counting parent)\n'));
-        }
-        // Ask how many implementation repositories
-        const { repoCount } = await inquirer.prompt([{
-                type: 'number',
-                name: 'repoCount',
-                message: useParent
-                    ? '📦 How many IMPLEMENTATION repositories? (not counting parent)'
-                    : 'How many repositories?',
-                default: hints.suggestedCount, // Use auto-detected count
-                validate: (input) => {
-                    if (input < 1)
-                        return useParent
-                            ? 'Need at least 1 implementation repository'
-                            : 'Need at least 2 repositories';
-                    if (input > 10)
-                        return 'Maximum 10 repositories supported';
-                    return true;
+            // 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)'));
                 }
-            }]);
-        // 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 {
+                    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'));
             }
-            else {
-                const totalRepos = 1 + repoCount;
-                console.log(chalk.green(`\n✓ Total repositories to create: ${totalRepos} (1 parent + ${repoCount} implementation)\n`));
+            // Ask how many implementation repositories
+            const promptResult = await inquirer.prompt([{
+                    type: 'number',
+                    name: 'repoCount',
+                    message: useParent
+                        ? '📦 How many IMPLEMENTATION repositories? (not counting parent)'
+                        : 'How many repositories?',
+                    default: hints.suggestedCount, // Use auto-detected count
+                    validate: (input) => {
+                        if (input < 1)
+                            return useParent
+                                ? 'Need at least 1 implementation repository'
+                                : 'Need at least 2 repositories';
+                        if (input > 10)
+                            return 'Maximum 10 repositories supported';
+                        return true;
+                    }
+                }]);
+            repoCount = promptResult.repoCount;
+            // 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 (optimization for many repos)
-        let discoveredRepos = [];
-        let bulkDiscoveryStrategy = 'manual';
-        if (this.githubToken && config.parentRepo) {
-            const octokit = new Octokit({ auth: this.githubToken });
-            const owner = config.parentRepo.owner;
-            const isOrg = await this.isGitHubOrganization(owner);
-            const discoveryResult = await discoverRepositories(octokit, owner, isOrg, repoCount);
-            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`));
-                        // Override repoCount with discovered count
-                        repoCount = discoveredRepos.length;
+            // 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;
+                        }
                     }
                 }
             }
@@ -646,7 +900,7 @@ export class RepoStructureManager {
                             return 'Repository name is required';
                         // Validate repository doesn't exist (skip for discovered repos)
                         if (!isDiscovered && this.githubToken && config.parentRepo) {
-                            const result = await validateRepository(config.parentRepo.owner, input, this.githubToken);
+                            const result = await provider.validateRepository(config.parentRepo.owner, input, this.githubToken);
                             if (result.exists) {
                                 return `Repository ${config.parentRepo.owner}/${input} already exists at ${result.url}`;
                             }
@@ -772,7 +1026,7 @@ export class RepoStructureManager {
     /**
      * Configure monorepo
      */
-    async configureMonorepo() {
+    async configureMonorepo(urlType = 'ssh', platform = 'github', provider) {
         console.log(chalk.cyan('\n📚 Monorepo Configuration\n'));
         console.log(chalk.gray('Single repository with multiple projects/packages.\n'));
         const answers = await inquirer.prompt([
@@ -834,6 +1088,9 @@ export class RepoStructureManager {
         const projects = answers.projects.split(',').map((p) => p.trim());
         return {
             architecture: 'monorepo',
+            urlType,
+            platform,
+            provider,
             repositories: [{
                     id: 'main',
                     name: answers.repo,
@@ -848,28 +1105,33 @@ export class RepoStructureManager {
         };
     }
     /**
-     * Create repositories on GitHub via API
+     * Create repositories on Git hosting platform via API
      */
-    async createGitHubRepositories(config) {
+    async createRepositories(config) {
         if (!this.githubToken) {
-            console.log(chalk.yellow('\n⚠️  No GitHub token available'));
-            console.log(chalk.gray('   Skipping GitHub repository creation'));
+            console.log(chalk.yellow(`\n⚠️  No ${config.provider.config.name} token available`));
+            console.log(chalk.gray(`   Skipping ${config.provider.config.name} repository creation`));
             console.log(chalk.gray('   You can create repositories manually later\n'));
             return;
         }
-        const spinner = ora('Creating GitHub repositories...').start();
+        const spinner = ora(`Creating ${config.provider.config.name} repositories...`).start();
         const created = [];
         const failed = [];
         // Create parent repository if needed
         if (config.parentRepo?.createOnGitHub) {
             try {
-                await this.createGitHubRepo(config.parentRepo.owner, config.parentRepo.name, config.parentRepo.description, config.parentRepo.visibility);
+                await config.provider.createRepository({
+                    owner: config.parentRepo.owner,
+                    name: config.parentRepo.name,
+                    description: config.parentRepo.description,
+                    visibility: config.parentRepo.visibility
+                }, this.githubToken);
                 created.push(`${config.parentRepo.owner}/${config.parentRepo.name}`);
                 // Save state: parent repo created
                 await this.saveSetupState({
                     version: '1.0.0',
                     architecture: config.architecture,
-                    parentRepo: { ...config.parentRepo, url: `https://github.com/${config.parentRepo.owner}/${config.parentRepo.name}` },
+                    parentRepo: { ...config.parentRepo, url: config.provider.getRemoteUrl(config.parentRepo.owner, config.parentRepo.name, config.urlType) },
                     repos: [],
                     currentStep: 'parent-repo-created',
                     timestamp: new Date().toISOString(),
@@ -884,7 +1146,12 @@ export class RepoStructureManager {
         for (const repo of config.repositories) {
             if (repo.createOnGitHub) {
                 try {
-                    await this.createGitHubRepo(repo.owner, repo.name, repo.description, repo.visibility);
+                    await config.provider.createRepository({
+                        owner: repo.owner,
+                        name: repo.name,
+                        description: repo.description,
+                        visibility: repo.visibility
+                    }, this.githubToken);
                     created.push(`${repo.owner}/${repo.name}`);
                 }
                 catch (error) {
@@ -973,7 +1240,7 @@ export class RepoStructureManager {
                 path: r.path,
                 visibility: r.visibility,
                 displayName: r.name,
-                url: `https://github.com/${r.owner}/${r.name}`,
+                url: config.provider.getRemoteUrl(r.owner, r.name, config.urlType),
                 created: false
             })),
             currentStep: 'complete',
@@ -1066,14 +1333,14 @@ export class RepoStructureManager {
     }
     /**
      * Clone or initialize a repository
-     * If the repo exists on GitHub, clone it; otherwise, init + add remote
+     * If the repo exists on the platform, clone it; otherwise, init + add remote
      */
-    async cloneOrInitRepository(repoPath, owner, name, createOnGitHub) {
+    async cloneOrInitRepository(repoPath, owner, name, createOnGitHub, urlType = 'ssh', provider) {
         // If .git already exists, skip
         if (existsSync(path.join(repoPath, '.git'))) {
             return;
         }
-        const remoteUrl = `https://github.com/${owner}/${name}.git`;
+        const remoteUrl = provider.getRemoteUrl(owner, name, urlType);
         // Check if repository exists on GitHub
         const repoExists = await this.repositoryExistsOnGitHub(owner, name);
         if (repoExists) {
@@ -1131,7 +1398,7 @@ export class RepoStructureManager {
             if (!existsSync(path.join(this.projectPath, '.git'))) {
                 execFileNoThrowSync('git', ['init'], { cwd: this.projectPath });
                 if (config.parentRepo) {
-                    const remoteUrl = `https://github.com/${config.parentRepo.owner}/${config.parentRepo.name}.git`;
+                    const remoteUrl = config.provider.getRemoteUrl(config.parentRepo.owner, config.parentRepo.name, config.urlType);
                     execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: this.projectPath });
                 }
             }
@@ -1139,7 +1406,7 @@ export class RepoStructureManager {
             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);
+                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);
@@ -1151,7 +1418,7 @@ export class RepoStructureManager {
             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);
+                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);
@@ -1164,7 +1431,7 @@ export class RepoStructureManager {
                 execFileNoThrowSync('git', ['init'], { cwd: this.projectPath });
                 const repo = config.repositories[0];
                 if (repo) {
-                    const remoteUrl = `https://github.com/${repo.owner}/${repo.name}.git`;
+                    const remoteUrl = config.provider.getRemoteUrl(repo.owner, repo.name, config.urlType);
                     execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: this.projectPath });
                 }
             }