@intranefr/superbackend 1.7.7 → 1.7.9

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

@@ -0,0 +1,706 @@
+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');
+
+/**
+ * Statistics and utility commands for AutoChangelog CLI
+ * Handles usage statistics, subscription info, and system utilities
+ */
+
+function setupStatsCommands(program) {
+  const stats = program
+    .command('stats')
+    .description('Show project statistics and usage');
+
+  // Project statistics command
+  stats
+    .command('project [project-id]')
+    .description('Show project statistics')
+    .option('--detailed', 'Show detailed statistics')
+    .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 getProjectStats(projectId, options.detailed, token, logger);
+        
+        if (output.isJsonMode()) {
+          output.output({
+            success: true,
+            data: result,
+            metadata: {
+              projectId,
+              detailed: options.detailed,
+              timestamp: new Date().toISOString(),
+            }
+          });
+        } else {
+          displayProjectStats(result, options.detailed);
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Usage command
+  stats
+    .command('usage')
+    .description('Show subscription usage')
+    .action(async () => {
+      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 getUsageStats(token, logger);
+        
+        if (output.isJsonMode()) {
+          output.output({
+            success: true,
+            data: result,
+            metadata: {
+              timestamp: new Date().toISOString(),
+            }
+          });
+        } else {
+          displayUsageStats(result);
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // System info command
+  stats
+    .command('system')
+    .description('Show system information')
+    .action(async () => {
+      const logger = setupLogger();
+      
+      try {
+        const config = loadConfig();
+        const token = getAuthToken();
+        
+        const result = await getSystemInfo(config, token, logger);
+        
+        if (output.isJsonMode()) {
+          output.output({
+            success: true,
+            data: result,
+            metadata: {
+              timestamp: new Date().toISOString(),
+            }
+          });
+        } else {
+          displaySystemInfo(result);
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+
+  // Health check command
+  stats
+    .command('health')
+    .description('Check system health')
+    .action(async () => {
+      const logger = setupLogger();
+      
+      try {
+        const config = loadConfig();
+        const token = getAuthToken();
+        
+        const result = await checkHealth(config, token, logger);
+        
+        if (output.isJsonMode()) {
+          output.output({
+            success: true,
+            data: result,
+            metadata: {
+              timestamp: new Date().toISOString(),
+            }
+          });
+        } else {
+          displayHealthCheck(result);
+        }
+
+      } catch (error) {
+        handleCliError(error, output);
+      }
+    });
+}
+
+/**
+ * Get project statistics
+ * @param {string} projectId - Project ID
+ * @param {boolean} detailed - Show detailed stats
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Project statistics
+ */
+async function getProjectStats(projectId, detailed, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Project = require('../../autochangelog/src/models/Project');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    // Get project info
+    const project = await Project.findById(projectId).lean();
+    if (!project) {
+      const error = new Error('Project not found');
+      error.code = ERROR_CODES.RESOURCE_NOT_FOUND;
+      error.type = 'resource_not_found';
+      throw error;
+    }
+
+    // Get repository count
+    const repositoryCount = await Repository.countDocuments({ projectId });
+    
+    // Get changelog stats
+    const changelogStats = await Changelog.aggregate([
+      { $match: { projectId } },
+      {
+        $group: {
+          _id: null,
+          total: { $sum: 1 },
+          generated: { $sum: { $cond: [{ $eq: ['$status', 'generated'] }, 1, 0] } },
+          public: { $sum: { $cond: ['$public', 1, 0] } },
+          totalSize: { $sum: { $ifNull: [{ $strLenBytes: '$content' }, 0] } },
+        }
+      }
+    ]);
+
+    const changelogData = changelogStats[0] || { total: 0, generated: 0, public: 0, totalSize: 0 };
+
+    // Get recent activity
+    const recentChangelogs = await Changelog.find({ projectId })
+      .sort({ createdAt: -1 })
+      .limit(5)
+      .lean();
+
+    const stats = {
+      project: {
+        id: project._id,
+        name: project.name,
+        plan: project.plan,
+        createdAt: project.createdAt,
+      },
+      repositories: {
+        total: repositoryCount,
+      },
+      changelogs: {
+        total: changelogData.total,
+        generated: changelogData.generated,
+        public: changelogData.public,
+        totalSize: changelogData.totalSize,
+        averageSize: changelogData.total > 0 ? Math.round(changelogData.totalSize / changelogData.total) : 0,
+      },
+      recentActivity: recentChangelogs.map(changelog => ({
+        id: changelog._id,
+        title: changelog.title,
+        format: changelog.format,
+        createdAt: changelog.createdAt,
+      })),
+    };
+
+    if (detailed) {
+      // Add detailed repository stats
+      const repositories = await Repository.find({ projectId }).lean();
+      stats.repositories.details = repositories.map(repo => ({
+        id: repo._id,
+        fullName: repo.fullName,
+        status: repo.status,
+        lastSync: repo.lastSync,
+        private: repo.private,
+      }));
+
+      // Add monthly breakdown
+      const monthlyStats = await Changelog.aggregate([
+        { $match: { projectId } },
+        {
+          $group: {
+            _id: { year: '$year', month: '$month' },
+            count: { $sum: 1 },
+            size: { $sum: { $ifNull: [{ $strLenBytes: '$content' }, 0] } },
+          }
+        },
+        { $sort: { '_id.year': -1, '_id.month': -1 } }
+      ]);
+
+      stats.monthlyBreakdown = monthlyStats;
+    }
+
+    logger.info(`Project stats retrieved: ${project.name}`);
+    
+    return stats;
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Get usage statistics
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Usage statistics
+ */
+async function getUsageStats(token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const Project = require('../../autochangelog/src/models/Project');
+    const Repository = require('../../autochangelog/src/models/Repository');
+    const Changelog = require('../../autochangelog/src/models/Changelog');
+    
+    await mongoose.connect(loadConfig().mongodb_uri);
+    
+    // Get all projects for the authenticated user
+    const projects = await Project.find().lean();
+    
+    const usage = {
+      projects: {
+        total: projects.length,
+        byPlan: {},
+      },
+      repositories: {
+        total: 0,
+      },
+      changelogs: {
+        total: 0,
+        generated: 0,
+        public: 0,
+        totalSize: 0,
+      },
+      limits: {
+        projects: { current: projects.length, limit: 100 },
+        repositories: { current: 0, limit: 1000 },
+        changelogs: { current: 0, limit: 10000 },
+      }
+    };
+
+    // Count by plan
+    projects.forEach(project => {
+      usage.projects.byPlan[project.plan] = (usage.projects.byPlan[project.plan] || 0) + 1;
+    });
+
+    // Get repository count
+    usage.repositories.total = await Repository.countDocuments();
+    usage.limits.repositories.current = usage.repositories.total;
+
+    // Get changelog stats
+    const changelogStats = await Changelog.aggregate([
+      {
+        $group: {
+          _id: null,
+          total: { $sum: 1 },
+          generated: { $sum: { $cond: [{ $eq: ['$status', 'generated'] }, 1, 0] } },
+          public: { $sum: { $cond: ['$public', 1, 0] } },
+          totalSize: { $sum: { $ifNull: [{ $strLenBytes: '$content' }, 0] } },
+        }
+      }
+    ]);
+
+    const changelogData = changelogStats[0] || { total: 0, generated: 0, public: 0, totalSize: 0 };
+    usage.changelogs = {
+      total: changelogData.total,
+      generated: changelogData.generated,
+      public: changelogData.public,
+      totalSize: changelogData.totalSize,
+    };
+    usage.limits.changelogs.current = changelogData.total;
+
+    logger.info('Usage stats retrieved');
+    
+    return usage;
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Get system information
+ * @param {Object} config - Configuration object
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} System information
+ */
+async function getSystemInfo(config, token, logger) {
+  try {
+    const os = require('os');
+    const mongoose = require('mongoose');
+    
+    // Test database connection
+    let dbStatus = 'unknown';
+    try {
+      await mongoose.connect(config.mongodb_uri);
+      dbStatus = 'connected';
+    } catch (error) {
+      dbStatus = 'disconnected';
+    }
+
+    const systemInfo = {
+      cli: {
+        version: require('../../../package.json').version,
+        nodeVersion: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        cwd: process.cwd(),
+      },
+      database: {
+        status: dbStatus,
+        uri: config.mongodb_uri ? config.mongodb_uri.replace(/\/\/.*@/, '//***:***@') : 'Not configured',
+      },
+      authentication: {
+        authenticated: !!token,
+        tokenPreview: token ? token.substring(0, 10) + '...' : 'Not set',
+      },
+      environment: {
+        nodeEnv: process.env.NODE_ENV || 'development',
+        homeDir: os.homedir(),
+        tempDir: os.tmpdir(),
+        uptime: process.uptime(),
+      },
+      paths: {
+        config: config.config_path,
+        cache: config.cache_path,
+      }
+    };
+
+    logger.info('System info retrieved');
+    
+    return systemInfo;
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Check system health
+ * @param {Object} config - Configuration object
+ * @param {string} token - Authentication token
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} Health check results
+ */
+async function checkHealth(config, token, logger) {
+  try {
+    const mongoose = require('mongoose');
+    const fs = require('fs-extra');
+    
+    const health = {
+      status: 'healthy',
+      checks: [],
+      timestamp: new Date().toISOString(),
+    };
+
+    // Check database connection
+    try {
+      await mongoose.connect(config.mongodb_uri);
+      health.checks.push({
+        name: 'database',
+        status: 'healthy',
+        message: 'Database connection successful',
+      });
+    } catch (error) {
+      health.status = 'unhealthy';
+      health.checks.push({
+        name: 'database',
+        status: 'unhealthy',
+        message: `Database connection failed: ${error.message}`,
+      });
+    }
+
+    // Check authentication
+    if (token) {
+      try {
+        const { Octokit } = require('@octokit/rest');
+        const octokit = new Octokit({ auth: token });
+        await octokit.rest.users.getAuthenticated();
+        health.checks.push({
+          name: 'authentication',
+          status: 'healthy',
+          message: 'GitHub authentication valid',
+        });
+      } catch (error) {
+        health.status = 'unhealthy';
+        health.checks.push({
+          name: 'authentication',
+          status: 'unhealthy',
+          message: 'GitHub authentication failed',
+        });
+      }
+    } else {
+      health.checks.push({
+        name: 'authentication',
+        status: 'warning',
+        message: 'No authentication token set',
+      });
+    }
+
+    // Check file system permissions
+    try {
+      const configDir = require('path').dirname(config.config_path);
+      await fs.ensureDir(configDir);
+      health.checks.push({
+        name: 'filesystem',
+        status: 'healthy',
+        message: 'Configuration directory accessible',
+      });
+    } catch (error) {
+      health.status = 'unhealthy';
+      health.checks.push({
+        name: 'filesystem',
+        status: 'unhealthy',
+        message: `File system access failed: ${error.message}`,
+      });
+    }
+
+    // Check GitHub API rate limit
+    if (token) {
+      try {
+        const { Octokit } = require('@octokit/rest');
+        const octokit = new Octokit({ auth: token });
+        const { data } = await octokit.rest.rateLimit.get();
+        
+        const remaining = data.rate.remaining;
+        const limit = data.rate.limit;
+        const resetTime = new Date(data.rate.reset * 1000);
+
+        health.checks.push({
+          name: 'github_rate_limit',
+          status: remaining > 100 ? 'healthy' : 'warning',
+          message: `Rate limit: ${remaining}/${limit} remaining, resets at ${resetTime.toISOString()}`,
+          details: {
+            remaining,
+            limit,
+            resetTime: resetTime.toISOString(),
+          }
+        });
+      } catch (error) {
+        health.checks.push({
+          name: 'github_rate_limit',
+          status: 'unknown',
+          message: 'Could not check GitHub rate limit',
+        });
+      }
+    }
+
+    logger.info(`Health check completed: ${health.status}`);
+    
+    return health;
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Display project statistics in human-readable format
+ * @param {Object} stats - Project statistics
+ * @param {boolean} detailed - Whether to show detailed stats
+ */
+function displayProjectStats(stats, detailed) {
+  console.log(chalk.cyan.bold(`📊 Project Statistics: ${stats.project.name}`));
+  console.log('');
+
+  // Basic info
+  console.log(chalk.blue('📋 Basic Information:'));
+  console.log(`   Project ID: ${stats.project.id}`);
+  console.log(`   Plan: ${chalk.yellow(stats.project.plan)}`);
+  console.log(`   Created: ${new Date(stats.project.createdAt).toLocaleDateString()}`);
+  console.log('');
+
+  // Repositories
+  console.log(chalk.blue('📦 Repositories:'));
+  console.log(`   Total: ${chalk.yellow(stats.repositories.total)}`);
+  console.log('');
+
+  // Changelogs
+  console.log(chalk.blue('📝 Changelogs:'));
+  console.log(`   Total: ${chalk.yellow(stats.changelogs.total)}`);
+  console.log(`   Generated: ${chalk.yellow(stats.changelogs.generated)}`);
+  console.log(`   Public: ${chalk.yellow(stats.changelogs.public)}`);
+  console.log(`   Average Size: ${chalk.yellow(formatBytes(stats.changelogs.averageSize))}`);
+  console.log(`   Total Size: ${chalk.yellow(formatBytes(stats.changelogs.totalSize))}`);
+  console.log('');
+
+  // Recent activity
+  console.log(chalk.blue('🕐 Recent Activity:'));
+  if (stats.recentActivity.length === 0) {
+    console.log('   No recent changelogs');
+  } else {
+    stats.recentActivity.forEach((changelog, index) => {
+      console.log(`   ${index + 1}. ${changelog.title} (${changelog.format}) - ${new Date(changelog.createdAt).toLocaleDateString()}`);
+    });
+  }
+  console.log('');
+
+  // Detailed stats
+  if (detailed) {
+    if (stats.repositories.details && stats.repositories.details.length > 0) {
+      console.log(chalk.blue('🔍 Repository Details:'));
+      stats.repositories.details.forEach(repo => {
+        const statusColor = repo.status === 'active' ? chalk.green : chalk.yellow;
+        console.log(`   • ${repo.fullName} ${statusColor(`[${repo.status}]`)} ${repo.private ? chalk.red('[PRIVATE]') : ''}`);
+      });
+      console.log('');
+    }
+
+    if (stats.monthlyBreakdown && stats.monthlyBreakdown.length > 0) {
+      console.log(chalk.blue('📅 Monthly Breakdown:'));
+      stats.monthlyBreakdown.forEach(month => {
+        console.log(`   ${month._id.year}-${month._id.month}: ${month.count} changelogs, ${formatBytes(month.size)} total`);
+      });
+      console.log('');
+    }
+  }
+}
+
+/**
+ * Display usage statistics in human-readable format
+ * @param {Object} usage - Usage statistics
+ */
+function displayUsageStats(usage) {
+  console.log(chalk.cyan.bold('📈 Subscription Usage'));
+  console.log('');
+
+  // Projects
+  console.log(chalk.blue('🏗️  Projects:'));
+  console.log(`   Total: ${chalk.yellow(usage.projects.total)} / ${usage.limits.projects.limit}`);
+  console.log(`   By Plan:`);
+  Object.entries(usage.projects.byPlan).forEach(([plan, count]) => {
+    console.log(`     ${plan}: ${chalk.yellow(count)}`);
+  });
+  console.log('');
+
+  // Repositories
+  console.log(chalk.blue('📦 Repositories:'));
+  console.log(`   Total: ${chalk.yellow(usage.repositories.total)} / ${usage.limits.repositories.limit}`);
+  console.log('');
+
+  // Changelogs
+  console.log(chalk.blue('📝 Changelogs:'));
+  console.log(`   Total: ${chalk.yellow(usage.changelogs.total)} / ${usage.limits.changelogs.limit}`);
+  console.log(`   Generated: ${chalk.yellow(usage.changelogs.generated)}`);
+  console.log(`   Public: ${chalk.yellow(usage.changelogs.public)}`);
+  console.log(`   Total Size: ${chalk.yellow(formatBytes(usage.changelogs.totalSize))}`);
+  console.log('');
+}
+
+/**
+ * Display system information in human-readable format
+ * @param {Object} systemInfo - System information
+ */
+function displaySystemInfo(systemInfo) {
+  console.log(chalk.cyan.bold('🖥️  System Information'));
+  console.log('');
+
+  // CLI Info
+  console.log(chalk.blue('🔧 CLI:'));
+  console.log(`   Version: ${chalk.yellow(systemInfo.cli.version)}`);
+  console.log(`   Node.js: ${chalk.yellow(systemInfo.cli.nodeVersion)}`);
+  console.log(`   Platform: ${chalk.yellow(systemInfo.cli.platform)} ${chalk.yellow(systemInfo.cli.arch)}`);
+  console.log(`   Working Directory: ${chalk.yellow(systemInfo.cli.cwd)}`);
+  console.log('');
+
+  // Database
+  console.log(chalk.blue('🗄️  Database:'));
+  const dbStatusColor = systemInfo.database.status === 'connected' ? chalk.green : chalk.red;
+  console.log(`   Status: ${dbStatusColor(systemInfo.database.status)}`);
+  console.log(`   URI: ${chalk.yellow(systemInfo.database.uri)}`);
+  console.log('');
+
+  // Authentication
+  console.log(chalk.blue('🔐 Authentication:'));
+  const authStatusColor = systemInfo.authentication.authenticated ? chalk.green : chalk.red;
+  console.log(`   Status: ${authStatusColor(systemInfo.authentication.authenticated ? 'Authenticated' : 'Not Authenticated')}`);
+  console.log(`   Token: ${chalk.yellow(systemInfo.authentication.tokenPreview)}`);
+  console.log('');
+
+  // Environment
+  console.log(chalk.blue('🌍 Environment:'));
+  console.log(`   Node Environment: ${chalk.yellow(systemInfo.environment.nodeEnv)}`);
+  console.log(`   Home Directory: ${chalk.yellow(systemInfo.environment.homeDir)}`);
+  console.log(`   Temp Directory: ${chalk.yellow(systemInfo.environment.tempDir)}`);
+  console.log(`   Uptime: ${chalk.yellow(formatUptime(systemInfo.environment.uptime))}`);
+  console.log('');
+
+  // Paths
+  console.log(chalk.blue('📁 Paths:'));
+  console.log(`   Config: ${chalk.yellow(systemInfo.paths.config)}`);
+  console.log(`   Cache: ${chalk.yellow(systemInfo.paths.cache)}`);
+  console.log('');
+}
+
+/**
+ * Display health check results in human-readable format
+ * @param {Object} health - Health check results
+ */
+function displayHealthCheck(health) {
+  const statusColor = health.status === 'healthy' ? chalk.green : chalk.red;
+  console.log(chalk.cyan.bold(`🏥 System Health: ${statusColor(health.status.toUpperCase())}`));
+  console.log('');
+
+  health.checks.forEach(check => {
+    const statusColor = check.status === 'healthy' ? chalk.green : check.status === 'warning' ? chalk.yellow : chalk.red;
+    console.log(`${statusColor(`• ${check.name}: ${check.status.toUpperCase()}`)}`);
+    console.log(`  ${chalk.gray(check.message)}`);
+    console.log('');
+  });
+
+  console.log(chalk.gray(`Last checked: ${new Date(health.timestamp).toLocaleString()}`));
+  console.log('');
+}
+
+/**
+ * Format bytes to human-readable format
+ * @param {number} bytes - Number of bytes
+ * @returns {string} Formatted string
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Format uptime to human-readable format
+ * @param {number} seconds - Uptime in seconds
+ * @returns {string} Formatted string
+ */
+function formatUptime(seconds) {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+
+  return `${days}d ${hours}h ${minutes}m ${secs}s`;
+}
+
+module.exports = setupStatsCommands;