specweave 0.24.0 → 0.24.6

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

@@ -14,7 +14,7 @@
  * - Organize specs per project/team
  * - Split tasks between repositories
  */
-import fs from 'fs-extra';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
@@ -28,6 +28,8 @@ import { generateEnvFile } from '../../utils/env-file-generator.js';
 import { generateSetupSummary } from './setup-summary.js';
 import { getArchitecturePrompt, getParentRepoBenefits, getVisibilityPrompt } from './prompt-consolidator.js';
 import { detectRepositoryHints } from './folder-detector.js';
+import { discoverRepositories } from './repo-bulk-discovery.js';
+import { Octokit } from '@octokit/rest';
 export class RepoStructureManager {
     constructor(projectPath, githubToken) {
         this.projectPath = projectPath;
@@ -127,7 +129,7 @@ export class RepoStructureManager {
     async configureSingleRepo() {
         console.log(chalk.cyan('\n📦 Single Repository Configuration\n'));
         // Check if repo already exists
-        const hasGit = fs.existsSync(path.join(this.projectPath, '.git'));
+        const hasGit = existsSync(path.join(this.projectPath, '.git'));
         if (hasGit) {
             // Try to detect existing remote
             try {
@@ -147,15 +149,36 @@ export class RepoStructureManager {
                             default: true
                         }]);
                     if (useExisting) {
+                        // Fetch description and visibility from GitHub API
+                        let description = `${repo} - SpecWeave project`;
+                        let visibility = 'private';
+                        if (this.githubToken) {
+                            try {
+                                const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+                                    headers: {
+                                        'Authorization': `Bearer ${this.githubToken}`,
+                                        'Accept': 'application/vnd.github+json'
+                                    }
+                                });
+                                if (response.ok) {
+                                    const data = await response.json();
+                                    description = data.description || description;
+                                    visibility = data.private ? 'private' : 'public';
+                                }
+                            }
+                            catch {
+                                // Use defaults if fetch fails
+                            }
+                        }
                         return {
                             architecture: 'single',
                             repositories: [{
                                     id: 'main',
                                     name: repo,
                                     owner: owner,
-                                    description: `${repo} - SpecWeave project`,
+                                    description: description,
                                     path: '.',
-                                    visibility: 'private', // Default for existing repo
+                                    visibility: visibility, // Fetched from GitHub API
                                     createOnGitHub: false,
                                     isNested: false
                                 }]
@@ -195,19 +218,23 @@ export class RepoStructureManager {
                 default: !hasGit
             }
         ]);
-        // 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;
+        }
         return {
             architecture: 'single',
             repositories: [{
@@ -360,8 +387,9 @@ export class RepoStructureManager {
                             }
                         }
                     ]);
-                    // Fetch description from GitHub API (or use default)
+                    // 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}`, {
@@ -373,17 +401,19 @@ export class RepoStructureManager {
                             if (response.ok) {
                                 const data = await response.json();
                                 description = data.description || description;
+                                existingVisibility = data.private ? 'private' : 'public';
                             }
                         }
                         catch {
-                            // Use default if fetch fails
+                            // Use defaults if fetch fails
                         }
                     }
                     parentAnswers = {
                         owner: ownerPrompt.owner,
                         parentName: repoPrompt.parentName,
                         description: description,
-                        createOnGitHub: false // Don't create, it already exists!
+                        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`));
                 }
@@ -447,9 +477,10 @@ export class RepoStructureManager {
                     parentAnswers = { ...ownerPrompt, ...remainingAnswers };
                 }
             }
-            // Ask about visibility for parent repo (only if creating on GitHub)
+            // Ask about visibility for parent repo (only if creating NEW repo on GitHub)
             let parentVisibility = 'private';
-            if (!isLocalParent) {
+            if (!isLocalParent && parentAnswers.createOnGitHub) {
+                // Only prompt for visibility when creating a NEW repository
                 const parentVisibilityPrompt = getVisibilityPrompt(parentAnswers.parentName);
                 const result = await inquirer.prompt([{
                         type: 'list',
@@ -464,6 +495,10 @@ export class RepoStructureManager {
                     }]);
                 parentVisibility = result.parentVisibility;
             }
+            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,
@@ -532,26 +567,85 @@ 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 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;
+                    }
+                }
+            }
+        }
         // 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) {
+                        // 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);
                             if (result.exists) {
                                 return `Repository ${config.parentRepo.owner}/${input} already exists at ${result.url}`;
@@ -570,7 +664,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)
@@ -616,19 +710,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,
@@ -713,22 +811,26 @@ export class RepoStructureManager {
                 type: 'confirm',
                 name: 'createOnGitHub',
                 message: 'Create repository on GitHub?',
-                default: !fs.existsSync(path.join(this.projectPath, '.git'))
+                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',
@@ -942,6 +1044,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 GitHub, clone it; otherwise, init + add remote
+     */
+    async cloneOrInitRepository(repoPath, owner, name, createOnGitHub) {
+        // If .git already exists, skip
+        if (existsSync(path.join(repoPath, '.git'))) {
+            return;
+        }
+        const remoteUrl = `https://github.com/${owner}/${name}.git`;
+        // 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
      */
@@ -951,7 +1128,7 @@ export class RepoStructureManager {
         if (config.architecture === 'parent') {
             // Parent repo approach: ROOT-LEVEL cloning (not services/!)
             // Initialize parent repo at root
-            if (!fs.existsSync(path.join(this.projectPath, '.git'))) {
+            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`;
@@ -961,38 +1138,29 @@ export class RepoStructureManager {
             // 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 (!fs.existsSync(repoPath)) {
-                    fs.mkdirSync(repoPath, { recursive: true });
-                }
-                // Initialize git
-                if (!fs.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);
+                // 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 (!fs.existsSync(repoPath)) {
-                    fs.mkdirSync(repoPath, { recursive: true });
-                }
-                if (!fs.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);
+                // 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 {
             // Single repo or monorepo
-            if (!fs.existsSync(path.join(this.projectPath, '.git'))) {
+            if (!existsSync(path.join(this.projectPath, '.git'))) {
                 execFileNoThrowSync('git', ['init'], { cwd: this.projectPath });
                 const repo = config.repositories[0];
                 if (repo) {
@@ -1004,8 +1172,8 @@ export class RepoStructureManager {
             if (config.architecture === 'monorepo' && config.monorepoProjects) {
                 for (const project of config.monorepoProjects) {
                     const projectPath = path.join(this.projectPath, 'packages', project);
-                    if (!fs.existsSync(projectPath)) {
-                        fs.mkdirSync(projectPath, { recursive: true });
+                    if (!existsSync(projectPath)) {
+                        mkdirSync(projectPath, { recursive: true });
                     }
                     this.createBasicRepoStructure(projectPath, project);
                 }
@@ -1024,21 +1192,21 @@ export class RepoStructureManager {
         const dirs = ['src', 'tests'];
         for (const dir of dirs) {
             const dirPath = path.join(repoPath, dir);
-            if (!fs.existsSync(dirPath)) {
-                fs.mkdirSync(dirPath, { recursive: true });
+            if (!existsSync(dirPath)) {
+                mkdirSync(dirPath, { recursive: true });
             }
         }
         // Create README.md
         const readmePath = path.join(repoPath, 'README.md');
-        if (!fs.existsSync(readmePath)) {
+        if (!existsSync(readmePath)) {
             const readmeContent = `# ${projectId}\n\n${projectId} service/component.\n\nPart of SpecWeave multi-repository project.\n`;
-            fs.writeFileSync(readmePath, readmeContent);
+            writeFileSync(readmePath, readmeContent);
         }
         // Create .gitignore
         const gitignorePath = path.join(repoPath, '.gitignore');
-        if (!fs.existsSync(gitignorePath)) {
+        if (!existsSync(gitignorePath)) {
             const gitignoreContent = `node_modules/\ndist/\n.env\n.DS_Store\n*.log\n`;
-            fs.writeFileSync(gitignorePath, gitignoreContent);
+            writeFileSync(gitignorePath, gitignoreContent);
         }
     }
     /**
@@ -1054,8 +1222,8 @@ export class RepoStructureManager {
             // Monorepo: create specs folder for each project
             for (const project of config.monorepoProjects) {
                 const projectSpecPath = path.join(specweavePath, 'docs', 'internal', 'specs', project.toLowerCase());
-                if (!fs.existsSync(projectSpecPath)) {
-                    fs.mkdirSync(projectSpecPath, { recursive: true });
+                if (!existsSync(projectSpecPath)) {
+                    mkdirSync(projectSpecPath, { recursive: true });
                 }
                 console.log(chalk.gray(`   ✓ Created project structure: ${project}`));
             }
@@ -1064,8 +1232,8 @@ export class RepoStructureManager {
             // 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 (!fs.existsSync(projectSpecPath)) {
-                    fs.mkdirSync(projectSpecPath, { recursive: true });
+                if (!existsSync(projectSpecPath)) {
+                    mkdirSync(projectSpecPath, { recursive: true });
                 }
                 console.log(chalk.gray(`   ✓ Created project structure: ${repo.id}`));
             }