@intranefr/superbackend 1.7.7 → 1.7.9

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

@@ -0,0 +1,619 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { output } = require('../utils/output');
+const { handleCliError, validateRequiredArgs, validateDateParams, ERROR_CODES } = require('../utils/errors');
+const { loadConfig, getAuthToken, getCacheDir } = require('../utils/config');
+const { setupLogger } = require('../utils/logger');
+
+/**
+ * Changelog generation commands for AutoChangelog CLI
+ * Handles changelog creation, listing, and management
+ */
+
+function setupChangelogCommands(program) {
+  const changelog = program
+    .command('changelog')
+    .description('Changelog management');
+
+  // Generate changelog command
+  changelog
+    .command('generate')
+    .description('Generate changelog for a project')
+    .option('--project-id <id>', 'Project ID')
+    .option('--repository-id <id>', 'Repository ID')
+    .option('--month <month>', 'Month to generate changelog for (1-12)', '0')
+    .option('--year <year>', 'Year to generate changelog for', new Date().getFullYear().toString())
+    .option('--format <format>', 'Output format (markdown, html, json)', 'markdown')
+    .option('--output <path>', 'Output file path')
+    .option('--title <title>', 'Custom changelog title')
+    .option('--include-merge-commits', 'Include merge commits in changelog')
+    .option('--include-drafts', 'Include draft changelogs')
+    .action(async (options) => {
+      const logger = setupLogger();
+      const config = loadConfig();
+      
+      try {
+        validateRequiredArgs(options, ['projectId'], output);
+        
+        const token = getAuthToken();
+        if (!token) {
+          output.error('Not authenticated. Run "autochangelog auth login" first.');
+          process.exit(ERROR_CODES.AUTHENTICATION_FAILED);
+        }
+
+        // Validate date parameters
+        validateDateParams(options.month, options.year, output);
+
+        const changelogData = {
+          projectId: options.projectId,
+          repositoryId: options.repositoryId,
+          month: parseInt(options.month),
+          year: parseInt(options.year),
+          format: options.format,
+          includeMergeCommits: options.includeMergeCommits,
+          includeDrafts: options.includeDrafts,
+          title: options.title,
+        };
+
+        output.progress('Generating changelog...', 0);
+        
+        const result = await generateChangelog(changelogData, token, logger);
+        
+        output.progress('Changelog generation completed', 100);
+        
+        // Handle output
+        if (options.output) {
+          await saveChangelogToFile(result, options.output, options.format, logger);
+          output.success(`Changelog saved to ${options.output}`);
+        } else {
+          output.output({
+            success: true,
+            message: 'Changelog generated successfully',
+            data: result,
+            metadata: {
+              timestamp: new Date().toISOString(),
+              action: 'changelog_generate',
+              format: options.format,
+            }
+          });
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // List changelogs command
+  changelog
+    .command('list [project-id]')
+    .description('List changelogs for a project')
+    .option('--repository-id <id>', 'Filter by repository ID')
+    .option('--month <month>', 'Filter by month (1-12)')
+    .option('--year <year>', 'Filter by year')
+    .option('--format <format>', 'Filter by format')
+    .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 listChangelogs(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 changelogs found for this project');
+            return;
+          }
+
+          output.info(`Found ${result.length} changelog(s):`);
+          console.log('');
+
+          const headers = ['ID', 'Title', 'Format', 'Month', 'Year', 'Status', 'Created'];
+          const rows = result.map(changelog => [
+            changelog.id || changelog._id,
+            changelog.title || 'Untitled',
+            changelog.format,
+            changelog.month,
+            changelog.year,
+            changelog.status,
+            new Date(changelog.createdAt).toLocaleDateString(),
+          ]);
+
+          output.table(headers, rows);
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Get changelog details command
+  changelog
+    .command('get <id>')
+    .description('Get changelog details')
+    .option('--content', 'Include full changelog content')
+    .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);
+        }
+
+        const result = await getChangelog(id, options.content, token, logger);
+        
+        output.output({
+          success: true,
+          message: 'Changelog details retrieved',
+          data: result,
+        });
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Share changelog command
+  changelog
+    .command('share <id>')
+    .description('Make changelog publicly accessible')
+    .option('--expire <days>', 'Expiration in days (0 for never expire)', parseInt)
+    .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);
+        }
+
+        const result = await shareChangelog(id, options.expire, token, logger);
+        
+        output.output({
+          success: true,
+          message: 'Changelog shared successfully',
+          data: result,
+        });
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Download changelog command
+  changelog
+    .command('download <id>')
+    .description('Download changelog content')
+    .option('--output <path>', 'Output file path')
+    .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);
+        }
+
+        const result = await downloadChangelog(id, token, logger);
+        
+        if (options.output) {
+          await saveChangelogToFile(result, options.output, result.format, logger);
+          output.success(`Changelog downloaded to ${options.output}`);
+        } else {
+          // Output content directly
+          if (output.isJsonMode()) {
+            output.output({
+              success: true,
+              data: result,
+            });
+          } else {
+            console.log(chalk.green('Changelog Content:'));
+            console.log('');
+            console.log(result.content);
+          }
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Delete changelog command
+  changelog
+    .command('delete <id>')
+    .description('Delete a changelog')
+    .option('--force', 'Skip confirmation prompt')
+    .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);
+        }
+
+        // Confirmation prompt (skip if --force)
+        if (!options.force) {
+          const inquirer = require('inquirer');
+          const answers = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: `Are you sure you want to delete changelog ${id}? This action cannot be undone.`,
+              default: false,
+            }
+          ]);
+
+          if (!answers.confirm) {
+            output.info('Operation cancelled');
+            return;
+          }
+        }
+
+        await deleteChangelog(id, token, logger);
+        
+        output.success(`Changelog ${id} deleted successfully`);
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+}
+
+/**
+ * Generate changelog for a project
+ * @param {Object} changelogData - Changelog generation data
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Generated changelog
+ */
+async function generateChangelog(changelogData, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    const ChangelogService = require('../../autochangelog/src/services/changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const changelogService = new ChangelogService();
+    
+    // Generate changelog content
+    const content = await changelogService.generateChangelog({
+      projectId: changelogData.projectId,
+      repositoryId: changelogData.repositoryId,
+      month: changelogData.month,
+      year: changelogData.year,
+      format: changelogData.format,
+      includeMergeCommits: changelogData.includeMergeCommits,
+      includeDrafts: changelogData.includeDrafts,
+    });
+
+    // Create changelog record
+    const changelog = new Changelog({
+      projectId: changelogData.projectId,
+      repositoryId: changelogData.repositoryId,
+      title: changelogData.title || `Changelog ${changelogData.month}/${changelogData.year}`,
+      content: content,
+      format: changelogData.format,
+      month: changelogData.month,
+      year: changelogData.year,
+      status: 'generated',
+      public: false,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await changelog.save();
+    
+    logger.info(`Changelog generated: ${changelog.title} (${changelog._id})`);
+    
+    return {
+      id: changelog._id,
+      projectId: changelog.projectId,
+      repositoryId: changelog.repositoryId,
+      title: changelog.title,
+      content: changelog.content,
+      format: changelog.format,
+      month: changelog.month,
+      year: changelog.year,
+      status: changelog.status,
+      public: changelog.public,
+      createdAt: changelog.createdAt,
+      updatedAt: changelog.updatedAt,
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * List changelogs 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 changelogs
+ */
+async function listChangelogs(projectId, options, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const query = { projectId };
+    
+    // Apply filters
+    if (options.repositoryId) {
+      query.repositoryId = options.repositoryId;
+    }
+    if (options.month) {
+      query.month = parseInt(options.month);
+    }
+    if (options.year) {
+      query.year = parseInt(options.year);
+    }
+    if (options.format) {
+      query.format = options.format;
+    }
+    
+    const limit = options.limit || 50;
+    const offset = options.offset || 0;
+    
+    const changelogs = await Changelog.find(query)
+      .sort({ createdAt: -1 })
+      .skip(offset)
+      .limit(limit)
+      .lean();
+
+    logger.info(`Retrieved ${changelogs.length} changelogs for project ${projectId}`);
+    
+    return changelogs.map(changelog => ({
+      id: changelog._id,
+      projectId: changelog.projectId,
+      repositoryId: changelog.repositoryId,
+      title: changelog.title,
+      format: changelog.format,
+      month: changelog.month,
+      year: changelog.year,
+      status: changelog.status,
+      public: changelog.public,
+      createdAt: changelog.createdAt,
+      updatedAt: changelog.updatedAt,
+      contentLength: changelog.content ? changelog.content.length : 0,
+    }));
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Get changelog details
+ * @param {string} id - Changelog ID
+ * @param {boolean} includeContent - Include full content
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Changelog details
+ */
+async function getChangelog(id, includeContent, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const query = includeContent ? {} : { content: 0 };
+    const changelog = await Changelog.findById(id, query).lean();
+    
+    if (!changelog) {
+      const error = new Error('Changelog not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    logger.info(`Retrieved changelog details: ${changelog.title}`);
+    
+    const result = {
+      id: changelog._id,
+      projectId: changelog.projectId,
+      repositoryId: changelog.repositoryId,
+      title: changelog.title,
+      format: changelog.format,
+      month: changelog.month,
+      year: changelog.year,
+      status: changelog.status,
+      public: changelog.public,
+      createdAt: changelog.createdAt,
+      updatedAt: changelog.updatedAt,
+      contentLength: changelog.content ? changelog.content.length : 0,
+    };
+
+    if (includeContent) {
+      result.content = changelog.content;
+    }
+
+    return result;
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Share changelog (make public)
+ * @param {string} id - Changelog ID
+ * @param {number} expireDays - Expiration in days
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Share result
+ */
+async function shareChangelog(id, expireDays, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const updateData = {
+      public: true,
+      updatedAt: new Date(),
+    };
+
+    if (expireDays && expireDays > 0) {
+      updateData.expiresAt = new Date(Date.now() + (expireDays * 24 * 60 * 60 * 1000));
+    }
+
+    const changelog = await Changelog.findByIdAndUpdate(
+      id,
+      updateData,
+      { new: true, runValidators: true }
+    ).lean();
+
+    if (!changelog) {
+      const error = new Error('Changelog not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    logger.info(`Changelog shared: ${changelog.title}`);
+    
+    return {
+      id: changelog._id,
+      title: changelog.title,
+      public: changelog.public,
+      expiresAt: changelog.expiresAt,
+      shareUrl: `${loadConfig().api_base_url}/api/changelogs/${changelog._id}/public`,
+      createdAt: changelog.createdAt,
+      updatedAt: changelog.updatedAt,
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Download changelog content
+ * @param {string} id - Changelog ID
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Download result
+ */
+async function downloadChangelog(id, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const changelog = await Changelog.findById(id).lean();
+    
+    if (!changelog) {
+      const error = new Error('Changelog not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    logger.info(`Changelog downloaded: ${changelog.title}`);
+    
+    return {
+      id: changelog._id,
+      title: changelog.title,
+      content: changelog.content,
+      format: changelog.format,
+      month: changelog.month,
+      year: changelog.year,
+      createdAt: changelog.createdAt,
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Delete changelog
+ * @param {string} id - Changelog ID
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ */
+async function deleteChangelog(id, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    const changelog = await Changelog.findByIdAndDelete(id);
+    
+    if (!changelog) {
+      const error = new Error('Changelog not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    logger.info(`Changelog deleted: ${changelog.title}`);
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Save changelog content to file
+ * @param {Object} changelog - Changelog data
+ * @param {string} filePath - Output file path
+ * @param {string} format - Output format
+ * @param {Object} logger - Logger instance
+ */
+async function saveChangelogToFile(changelog, filePath, format, logger) {
+  try {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    await fs.ensureDir(dir);
+
+    // Write file
+    await fs.writeFile(filePath, changelog.content);
+
+    logger.info(`Changelog saved to: ${filePath}`);
+  } catch (error) {
+    throw new Error(`Failed to save changelog to file: ${error.message}`);
+  }
+}
+
+module.exports = setupChangelogCommands;