@intranefr/superbackend 1.7.7 → 1.7.9

package/autochangelog-cli/src/cli/commands/repo.js

@@ -0,0 +1,557 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { output } = require('../utils/output');
+const { handleCliError, validateRequiredArgs, ERROR_CODES } = require('../utils/errors');
+const { loadConfig, getAuthToken } = require('../utils/config');
+const { setupLogger } = require('../utils/logger');
+
+/**
+ * Repository management commands for AutoChangelog CLI
+ * Handles GitHub repository connection and management
+ */
+
+function setupRepoCommands(program) {
+  const repo = program
+    .command('repo')
+    .description('Repository management');
+
+  // Connect repository command
+  repo
+    .command('connect')
+    .description('Connect a GitHub repository')
+    .option('--project-id <id>', 'Project ID')
+    .option('--owner <owner>', 'Repository owner (username or organization)')
+    .option('--name <name>', 'Repository name')
+    .option('--url <url>', 'Repository URL (alternative to owner/name)')
+    .option('--branch <branch>', 'Default branch to track', 'main')
+    .action(async (options) => {
+      const logger = setupLogger();
+      const config = loadConfig();
+      
+      try {
+        // Validate required arguments
+        if (!options.projectId) {
+          output.error('Project ID is required. Use --project-id');
+          process.exit(ERROR_CODES.INVALID_ARGUMENT);
+        }
+
+        const token = getAuthToken();
+        if (!token) {
+          output.error('Not authenticated. Run "autochangelog auth login" first.');
+          process.exit(ERROR_CODES.AUTHENTICATION_FAILED);
+        }
+
+        // Parse repository information
+        let owner, name;
+        if (options.url) {
+          const parsed = parseRepoUrl(options.url);
+          owner = parsed.owner;
+          name = parsed.name;
+        } else if (options.owner && options.name) {
+          owner = options.owner;
+          name = options.name;
+        } else {
+          output.error('Repository information required. Use --owner and --name, or --url');
+          process.exit(ERROR_CODES.INVALID_ARGUMENT);
+        }
+
+        const repoData = {
+          projectId: options.projectId,
+          owner,
+          name,
+          defaultBranch: options.branch,
+        };
+
+        const result = await connectRepository(repoData, token, logger);
+        
+        output.output({
+          success: true,
+          message: 'Repository connected successfully',
+          data: result,
+          metadata: {
+            timestamp: new Date().toISOString(),
+            action: 'repository_connect',
+          }
+        });
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // List repositories command
+  repo
+    .command('list [project-id]')
+    .description('List repositories for a project')
+    .option('--limit <limit>', 'Limit number of results', parseInt)
+    .option('--offset <offset>', 'Offset for pagination', parseInt)
+    .action(async (projectId, options) => {
+      const logger = setupLogger();
+      
+      try {
+        const token = getAuthToken();
+        if (!token) {
+          output.error('Not authenticated. Run "autochangelog auth login" first.');
+          process.exit(ERROR_CODES.AUTHENTICATION_FAILED);
+        }
+
+        if (!projectId) {
+          output.error('Project ID is required');
+          process.exit(ERROR_CODES.INVALID_ARGUMENT);
+        }
+
+        const result = await listRepositories(projectId, options, token, logger);
+        
+        if (output.isJsonMode()) {
+          output.output({
+            success: true,
+            data: result,
+            metadata: {
+              projectId,
+              total: result.length,
+              limit: options.limit,
+              offset: options.offset || 0,
+            }
+          });
+        } else {
+          if (result.length === 0) {
+            output.info('No repositories found for this project');
+            return;
+          }
+
+          output.info(`Found ${result.length} repository(ies):`);
+          console.log('');
+
+          const headers = ['ID', 'Owner', 'Name', 'Branch', 'Status', 'Last Sync'];
+          const rows = result.map(repo => [
+            repo.id || repo._id,
+            repo.owner,
+            repo.name,
+            repo.defaultBranch,
+            repo.status || 'active',
+            repo.lastSync ? new Date(repo.lastSync).toLocaleDateString() : 'Never',
+          ]);
+
+          output.table(headers, rows);
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Sync repository command
+  repo
+    .command('sync <id>')
+    .description('Sync repository data from GitHub')
+    .option('--force', 'Force full resync')
+    .action(async (id, options) => {
+      const logger = setupLogger();
+      
+      try {
+        const token = getAuthToken();
+        if (!token) {
+          output.error('Not authenticated. Run "autochangelog auth login" first.');
+          process.exit(ERROR_CODES.AUTHENTICATION_FAILED);
+        }
+
+        output.progress('Starting repository sync...', 0);
+        
+        const result = await syncRepository(id, options.force, token, logger);
+        
+        output.progress('Repository sync completed', 100);
+        
+        output.output({
+          success: true,
+          message: 'Repository synced successfully',
+          data: result,
+          metadata: {
+            timestamp: new Date().toISOString(),
+            action: 'repository_sync',
+          }
+        });
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Validate repository command
+  repo
+    .command('validate <id>')
+    .description('Validate repository access and configuration')
+    .action(async (id) => {
+      const logger = setupLogger();
+      
+      try {
+        const token = getAuthToken();
+        if (!token) {
+          output.error('Not authenticated. Run "autochangelog auth login" first.');
+          process.exit(ERROR_CODES.AUTHENTICATION_FAILED);
+        }
+
+        output.progress('Validating repository access...');
+        
+        const result = await validateRepository(id, token, logger);
+        
+        output.output({
+          success: true,
+          message: 'Repository validation completed',
+          data: result,
+        });
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Get repository details command
+  repo
+    .command('get <id>')
+    .description('Get repository details')
+    .action(async (id) => {
+      const logger = setupLogger();
+      
+      try {
+        const token = getAuthToken();
+        if (!token) {
+          output.error('Not authenticated. Run "autochangelog auth login" first.');
+          process.exit(ERROR_CODES.AUTHENTICATION_FAILED);
+        }
+
+        const result = await getRepository(id, token, logger);
+        
+        output.output({
+          success: true,
+          message: 'Repository details retrieved',
+          data: result,
+        });
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+}
+
+/**
+ * Connect a GitHub repository
+ * @param {Object} repoData - Repository data
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Connected repository
+ */
+async function connectRepository(repoData, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    const GitHubService = require('../../autochangelog/src/services/github');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    // Validate repository access on GitHub
+    const githubService = new GitHubService(token);
+    const repoInfo = await githubService.getRepository(repoData.owner, repoData.name);
+    
+    if (!repoInfo) {
+      const error = new Error('Repository not found or access denied');
+      error.code = ERROR_CODES.PERMISSION_DENIED;
+      error.type = 'permission_denied';
+      throw error;
+    }
+
+    // Create repository record
+    const repository = new Repository({
+      projectId: repoData.projectId,
+      owner: repoData.owner,
+      name: repoData.name,
+      fullName: repoInfo.full_name,
+      defaultBranch: repoData.defaultBranch || 'main',
+      githubId: repoInfo.id,
+      private: repoInfo.private,
+      description: repoInfo.description,
+      url: repoInfo.html_url,
+      cloneUrl: repoInfo.clone_url,
+      status: 'active',
+      lastSync: new Date(),
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await repository.save();
+    
+    logger.info(`Repository connected: ${repoInfo.full_name} (${repository._id})`);
+    
+    return {
+      id: repository._id,
+      owner: repository.owner,
+      name: repository.name,
+      fullName: repository.fullName,
+      defaultBranch: repository.defaultBranch,
+      status: repository.status,
+      createdAt: repository.createdAt,
+      updatedAt: repository.updatedAt,
+      githubInfo: {
+        id: repoInfo.id,
+        private: repoInfo.private,
+        description: repoInfo.description,
+        url: repoInfo.html_url,
+      }
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * List repositories for a project
+ * @param {string} projectId - Project ID
+ * @param {Object} options - Query options
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Array>} List of repositories
+ */
+async function listRepositories(projectId, options, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const query = { projectId };
+    const limit = options.limit || 50;
+    const offset = options.offset || 0;
+    
+    const repositories = await Repository.find(query)
+      .sort({ createdAt: -1 })
+      .skip(offset)
+      .limit(limit)
+      .lean();
+
+    logger.info(`Retrieved ${repositories.length} repositories for project ${projectId}`);
+    
+    return repositories.map(repo => ({
+      id: repo._id,
+      owner: repo.owner,
+      name: repo.name,
+      fullName: repo.fullName,
+      defaultBranch: repo.defaultBranch,
+      status: repo.status,
+      private: repo.private,
+      description: repo.description,
+      url: repo.url,
+      lastSync: repo.lastSync,
+      createdAt: repo.createdAt,
+      updatedAt: repo.updatedAt,
+    }));
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Sync repository data from GitHub
+ * @param {string} id - Repository ID
+ * @param {boolean} force - Force full resync
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Sync result
+ */
+async function syncRepository(id, force, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    const GitHubService = require('../../autochangelog/src/services/github');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      const error = new Error('Repository not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    const githubService = new GitHubService(token);
+    
+    // Update last sync time
+    repository.lastSync = new Date();
+    repository.updatedAt = new Date();
+    await repository.save();
+
+    // Sync repository info
+    const repoInfo = await githubService.getRepository(repository.owner, repository.name);
+    
+    if (repoInfo) {
+      repository.fullName = repoInfo.full_name;
+      repository.private = repoInfo.private;
+      repository.description = repoInfo.description;
+      repository.url = repoInfo.html_url;
+      repository.cloneUrl = repoInfo.clone_url;
+      repository.updatedAt = new Date();
+      await repository.save();
+    }
+
+    logger.info(`Repository synced: ${repository.fullName}`);
+    
+    return {
+      id: repository._id,
+      fullName: repository.fullName,
+      lastSync: repository.lastSync,
+      status: 'synced',
+      changes: {
+        description: repoInfo ? repoInfo.description : repository.description,
+        private: repoInfo ? repoInfo.private : repository.private,
+      }
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Validate repository access and configuration
+ * @param {string} id - Repository ID
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Validation result
+ */
+async function validateRepository(id, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    const GitHubService = require('../../autochangelog/src/services/github');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      const error = new Error('Repository not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    const githubService = new GitHubService(token);
+    
+    // Test repository access
+    const repoInfo = await githubService.getRepository(repository.owner, repository.name);
+    
+    const validation = {
+      repositoryId: repository._id,
+      fullName: repository.fullName,
+      access: {
+        granted: !!repoInfo,
+        message: repoInfo ? 'Access granted' : 'Access denied or repository not found',
+      },
+      configuration: {
+        owner: repository.owner,
+        name: repository.name,
+        defaultBranch: repository.defaultBranch,
+        private: repository.private,
+      },
+      lastSync: repository.lastSync,
+      status: repository.status,
+    };
+
+    if (repoInfo) {
+      validation.githubInfo = {
+        id: repoInfo.id,
+        fullName: repoInfo.full_name,
+        private: repoInfo.private,
+        description: repoInfo.description,
+        defaultBranch: repoInfo.default_branch,
+      };
+    }
+
+    logger.info(`Repository validation completed: ${repository.fullName}`);
+    
+    return validation;
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Get repository details
+ * @param {string} id - Repository ID
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Repository details
+ */
+async function getRepository(id, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const repository = await Repository.findById(id).lean();
+    
+    if (!repository) {
+      const error = new Error('Repository not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    logger.info(`Retrieved repository details: ${repository.fullName}`);
+    
+    return {
+      id: repository._id,
+      projectId: repository.projectId,
+      owner: repository.owner,
+      name: repository.name,
+      fullName: repository.fullName,
+      defaultBranch: repository.defaultBranch,
+      status: repository.status,
+      private: repository.private,
+      description: repository.description,
+      url: repository.url,
+      cloneUrl: repository.cloneUrl,
+      githubId: repository.githubId,
+      lastSync: repository.lastSync,
+      createdAt: repository.createdAt,
+      updatedAt: repository.updatedAt,
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Parse repository URL to extract owner and name
+ * @param {string} url - Repository URL
+ * @returns {Object} Parsed owner and name
+ */
+function parseRepoUrl(url) {
+  try {
+    // Handle various GitHub URL formats
+    const patterns = [
+      /^https?:\/\/github\.com\/([^/]+)\/([^/]+)(?:\.git)?$/i,
+      /^git@github\.com:([^/]+)\/([^/]+)(?:\.git)?$/i,
+      /^github:([^/]+)\/([^/]+)$/i,
+    ];
+
+    for (const pattern of patterns) {
+      const match = url.match(pattern);
+      if (match) {
+        return {
+          owner: match[1],
+          name: match[2],
+        };
+      }
+    }
+
+    throw new Error('Invalid repository URL format');
+  } catch (error) {
+    throw new Error(`Failed to parse repository URL: ${error.message}`);
+  }
+}
+
+module.exports = setupRepoCommands;