specweave 0.24.1 → 0.24.8

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

@@ -23,16 +23,22 @@ 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
@@ -73,14 +79,53 @@ export class RepoStructureManager {
                 })),
                 default: 'single'
             }]);
+        // 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: 'urlType',
+                message: urlTypePromptData.question,
+                choices: urlTypePromptData.options.map(opt => ({
+                    name: `${opt.label}\n${chalk.gray(opt.description)}`,
+                    value: opt.value,
+                    short: opt.label
+                })),
+                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}`);
         }
@@ -102,9 +147,18 @@ export class RepoStructureManager {
      * 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,
@@ -124,7 +178,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'));
@@ -170,6 +224,9 @@ export class RepoStructureManager {
                         }
                         return {
                             architecture: 'single',
+                            urlType,
+                            platform,
+                            provider,
                             repositories: [{
                                     id: 'main',
                                     name: repo,
@@ -235,6 +292,9 @@ export class RepoStructureManager {
         }
         return {
             architecture: 'single',
+            urlType,
+            platform,
+            provider,
             repositories: [{
                     id: 'main',
                     name: answers.repo,
@@ -251,12 +311,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
@@ -266,6 +329,9 @@ export class RepoStructureManager {
         }
         const config = {
             architecture: useParent ? 'parent' : 'multi-repo',
+            urlType,
+            platform,
+            provider,
             repositories: []
         };
         // Save state: architecture selected
@@ -300,15 +366,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;
@@ -349,15 +415,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;
@@ -374,11 +440,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;
@@ -423,15 +489,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;
@@ -450,7 +516,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.`;
                                     }
@@ -565,27 +631,92 @@ export class RepoStructureManager {
                 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 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`));
+                        // Override repoCount with discovered count
+                        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 = suggestRepoName(projectName, i, repoCount);
+            const suggestedName = isDiscovered ? discoveredRepo.name : suggestRepoName(projectName, i, repoCount);
+            // If discovered, show preview and skip prompts (or allow confirmation)
+            if (isDiscovered) {
+                console.log(chalk.green(`   ✓ Discovered: ${chalk.bold(discoveredRepo.name)}`));
+                console.log(chalk.gray(`     Description: ${discoveredRepo.description || '(none)'}`));
+                console.log(chalk.gray(`     Visibility: ${discoveredRepo.private ? 'Private' : 'Public'}`));
+                const { confirmDiscovered } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'confirmDiscovered',
+                        message: 'Use this repository configuration?',
+                        default: true
+                    }]);
+                if (!confirmDiscovered) {
+                    // Allow manual override
+                    console.log(chalk.yellow(`   → Switching to manual entry for this repository\n`));
+                }
+                else {
+                    // Use discovered repo configuration directly
+                    const smartId = generateRepoIdSmart(discoveredRepo.name, configuredRepoNames);
+                    const { id: suggestedId } = ensureUniqueId(smartId, usedIds);
+                    console.log(chalk.green(`   ✓ Repository ID: ${chalk.bold(suggestedId)} ${chalk.gray('(auto-generated)')}`));
+                    usedIds.add(suggestedId);
+                    configuredRepoNames.push(discoveredRepo.name);
+                    config.repositories.push({
+                        id: suggestedId,
+                        name: discoveredRepo.name,
+                        owner: discoveredRepo.owner,
+                        description: discoveredRepo.description || `${discoveredRepo.name} service`,
+                        path: useParent ? suggestedId : suggestedId,
+                        visibility: discoveredRepo.private ? 'private' : 'public',
+                        createOnGitHub: false, // Already exists!
+                        isNested: useParent
+                    });
+                    continue; // Skip manual prompts
+                }
+            }
+            // Manual entry (original behavior)
             const repoAnswers = await inquirer.prompt([
                 {
                     type: 'input',
                     name: 'name',
                     message: 'Repository name:',
-                    default: suggestedName, // Now suggests for ALL repos!
+                    default: suggestedName,
                     validate: async (input) => {
                         if (!input.trim())
                             return 'Repository name is required';
-                        // Validate repository doesn't exist
-                        if (this.githubToken && config.parentRepo) {
-                            const result = await validateRepository(config.parentRepo.owner, input, this.githubToken);
+                        // Validate repository doesn't exist (skip for discovered repos)
+                        if (!isDiscovered && this.githubToken && config.parentRepo) {
+                            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}`;
                             }
@@ -603,7 +734,7 @@ export class RepoStructureManager {
                     type: 'confirm',
                     name: 'createOnGitHub',
                     message: 'Create this repository on GitHub?',
-                    default: true
+                    default: !isDiscovered // Default to true for new repos, false for discovered
                 }
             ]);
             // Smart auto-generate ID from repository name (context-aware)
@@ -649,19 +780,23 @@ export class RepoStructureManager {
             }
             usedIds.add(id);
             configuredRepoNames.push(repoAnswers.name);
-            // Ask about visibility
-            const visibilityPrompt = getVisibilityPrompt(repoAnswers.name);
-            const { visibility } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'visibility',
-                    message: visibilityPrompt.question,
-                    choices: visibilityPrompt.options.map(opt => ({
-                        name: `${opt.label}\n${chalk.gray(opt.description)}`,
-                        value: opt.value,
-                        short: opt.label
-                    })),
-                    default: visibilityPrompt.default
-                }]);
+            // Ask about visibility only if creating a new repository
+            let visibility = 'private';
+            if (repoAnswers.createOnGitHub) {
+                const visibilityPrompt = getVisibilityPrompt(repoAnswers.name);
+                const result = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'visibility',
+                        message: visibilityPrompt.question,
+                        choices: visibilityPrompt.options.map(opt => ({
+                            name: `${opt.label}\n${chalk.gray(opt.description)}`,
+                            value: opt.value,
+                            short: opt.label
+                        })),
+                        default: visibilityPrompt.default
+                    }]);
+                visibility = result.visibility;
+            }
             config.repositories.push({
                 id: id,
                 name: repoAnswers.name,
@@ -707,7 +842,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([
@@ -749,22 +884,29 @@ export class RepoStructureManager {
                 default: !existsSync(path.join(this.projectPath, '.git'))
             }
         ]);
-        // Ask about visibility
-        const visibilityPrompt = getVisibilityPrompt(answers.repo);
-        const { visibility } = await inquirer.prompt([{
-                type: 'list',
-                name: 'visibility',
-                message: visibilityPrompt.question,
-                choices: visibilityPrompt.options.map(opt => ({
-                    name: `${opt.label}\n${chalk.gray(opt.description)}`,
-                    value: opt.value,
-                    short: opt.label
-                })),
-                default: visibilityPrompt.default
-            }]);
+        // Ask about visibility only if creating a new repository
+        let visibility = 'private';
+        if (answers.createOnGitHub) {
+            const visibilityPrompt = getVisibilityPrompt(answers.repo);
+            const result = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'visibility',
+                    message: visibilityPrompt.question,
+                    choices: visibilityPrompt.options.map(opt => ({
+                        name: `${opt.label}\n${chalk.gray(opt.description)}`,
+                        value: opt.value,
+                        short: opt.label
+                    })),
+                    default: visibilityPrompt.default
+                }]);
+            visibility = result.visibility;
+        }
         const projects = answers.projects.split(',').map((p) => p.trim());
         return {
             architecture: 'monorepo',
+            urlType,
+            platform,
+            provider,
             repositories: [{
                     id: 'main',
                     name: answers.repo,
@@ -779,28 +921,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(),
@@ -815,7 +962,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) {
@@ -904,7 +1056,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',
@@ -975,6 +1127,81 @@ 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
      */
@@ -987,40 +1214,31 @@ 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 });
                 }
             }
             // Initialize implementation repos at ROOT LEVEL
             for (const repo of config.repositories) {
                 const repoPath = path.join(this.projectPath, repo.path);
-                // Create directory if needed
-                if (!existsSync(repoPath)) {
-                    mkdirSync(repoPath, { recursive: true });
-                }
-                // Initialize git
-                if (!existsSync(path.join(repoPath, '.git'))) {
-                    execFileNoThrowSync('git', ['init'], { cwd: repoPath });
-                    const remoteUrl = `https://github.com/${repo.owner}/${repo.name}.git`;
-                    execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: repoPath });
+                // 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);
                 }
-                // Create basic structure
-                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);
-                if (!existsSync(repoPath)) {
-                    mkdirSync(repoPath, { recursive: true });
-                }
-                if (!existsSync(path.join(repoPath, '.git'))) {
-                    execFileNoThrowSync('git', ['init'], { cwd: repoPath });
-                    const remoteUrl = `https://github.com/${repo.owner}/${repo.name}.git`;
-                    execFileNoThrowSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: repoPath });
+                // 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);
                 }
-                this.createBasicRepoStructure(repoPath, repo.id);
             }
         }
         else {
@@ -1029,7 +1247,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 });
                 }
             }