easybuild-nox 1.0.0

package/src/commands/health.js

@@ -0,0 +1,261 @@
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+const ProjectDetector = require('../utils/detector');
+
+const healthCommand = new Command('health')
+  .description('Check project health and issues')
+  .option('--fix', 'Auto-fix issues where possible', false)
+  .action(async (options) => {
+    logger.header('🏥 Health Check');
+
+    const detector = new ProjectDetector();
+
+    try {
+      const projectInfo = await detector.detect();
+      const issues = [];
+      const warnings = [];
+      const passed = [];
+
+      // Check package.json
+      await checkPackageJson(issues, warnings, passed);
+
+      // Check dependencies
+      await checkDependencies(issues, warnings, passed);
+
+      // Check for security issues
+      await checkSecurity(issues, warnings, passed);
+
+      // Check for best practices
+      await checkBestPractices(projectInfo, issues, warnings, passed);
+
+      // Check for common issues
+      await checkCommonIssues(issues, warnings, passed);
+
+      // Print results
+      printHealthResults(passed, warnings, issues);
+
+      // Auto-fix if requested
+      if (options.fix) {
+        await autoFix(issues);
+      }
+    } catch (error) {
+      logger.error(`Health check failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function checkPackageJson(issues, warnings, passed) {
+  const pkgPath = path.join(process.cwd(), 'package.json');
+
+  if (!(await fs.pathExists(pkgPath))) {
+    issues.push('No package.json found');
+    return;
+  }
+
+  passed.push('package.json exists');
+
+  const pkg = await fs.readJson(pkgPath);
+
+  if (!pkg.name) issues.push('Missing "name" in package.json');
+  else passed.push('Has package name');
+
+  if (!pkg.version) warnings.push('Missing "version" in package.json');
+  else passed.push('Has version');
+
+  if (!pkg.description) warnings.push('Missing "description" in package.json');
+
+  if (!pkg.main && !pkg.bin) warnings.push('No main or bin entry');
+  else passed.push('Has entry point');
+
+  if (pkg.license) passed.push('Has license');
+  else warnings.push('No license specified');
+}
+
+async function checkDependencies(issues, warnings, passed) {
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (!(await fs.pathExists(pkgPath))) return;
+
+  const pkg = await fs.readJson(pkgPath);
+  const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+
+  if (await fs.pathExists(nodeModulesPath)) {
+    passed.push('node_modules exists');
+  } else {
+    warnings.push('node_modules not found - run npm install');
+  }
+
+  // Check for outdated dependencies
+  try {
+    const { execSync } = require('child_process');
+    const outdated = execSync('npm outdated --json', { encoding: 'utf8' });
+    const outdatedCount = Object.keys(JSON.parse(outdated)).length;
+    if (outdatedCount > 0) {
+      warnings.push(`${outdatedCount} outdated dependencies`);
+    } else {
+      passed.push('All dependencies up to date');
+    }
+  } catch {
+    // npm outdated returns non-zero if there are outdated packages
+  }
+
+  // Check for security vulnerabilities
+  try {
+    const { execSync } = require('child_process');
+    execSync('npm audit --audit-level=high', { encoding: 'utf8' });
+    passed.push('No high-severity vulnerabilities');
+  } catch {
+    warnings.push('Potential security vulnerabilities - run npm audit');
+  }
+}
+
+async function checkSecurity(issues, warnings, passed) {
+  // Check for .env file in git
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+  if (await fs.pathExists(gitignorePath)) {
+    const gitignore = await fs.readFile(gitignorePath, 'utf8');
+    if (gitignore.includes('.env')) {
+      passed.push('.env is gitignored');
+    } else {
+      warnings.push('.env is not gitignored - add it for security');
+    }
+  }
+
+  // Check for secrets in code
+  const srcDir = path.join(process.cwd(), 'src');
+  if (await fs.pathExists(srcDir)) {
+    // This is a simplified check
+    passed.push('Basic security checks passed');
+  }
+}
+
+async function checkBestPractices(projectInfo, issues, warnings, passed) {
+  // Check for TypeScript
+  if (projectInfo.isTypeScript) {
+    passed.push('TypeScript configured');
+  }
+
+  // Check for ESLint
+  const eslintPath = path.join(process.cwd(), '.eslintrc.json');
+  const eslintPathJs = path.join(process.cwd(), '.eslintrc.js');
+  if (await fs.pathExists(eslintPath) || await fs.pathExists(eslintPathJs)) {
+    passed.push('ESLint configured');
+  } else {
+    warnings.push('No ESLint configuration found');
+  }
+
+  // Check for Prettier
+  const prettierPath = path.join(process.cwd(), '.prettierrc');
+  if (await fs.pathExists(prettierPath)) {
+    passed.push('Prettier configured');
+  } else {
+    warnings.push('No Prettier configuration found');
+  }
+
+  // Check for tests
+  const testDirs = ['__tests__', 'test', 'tests', 'spec'];
+  const hasTests = testDirs.some(dir => 
+    fs.pathExists(path.join(process.cwd(), dir))
+  );
+  if (hasTests) {
+    passed.push('Test directory found');
+  } else {
+    warnings.push('No test directory found');
+  }
+
+  // Check for README
+  const readmePath = path.join(process.cwd(), 'README.md');
+  if (await fs.pathExists(readmePath)) {
+    passed.push('README.md exists');
+  } else {
+    warnings.push('No README.md found');
+  }
+
+  // Check for .gitignore
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+  if (await fs.pathExists(gitignorePath)) {
+    passed.push('.gitignore exists');
+  } else {
+    warnings.push('No .gitignore found');
+  }
+}
+
+async function checkCommonIssues(issues, warnings, passed) {
+  // Check for common config files
+  const configFiles = [
+    '.env',
+    '.env.local',
+    'tsconfig.json',
+    'jest.config.js',
+    'vite.config.js',
+    'webpack.config.js',
+  ];
+
+  for (const file of configFiles) {
+    if (await fs.pathExists(path.join(process.cwd(), file))) {
+      passed.push(`Has ${file}`);
+    }
+  }
+
+  // Check for circular dependencies (simplified)
+  passed.push('No circular dependencies detected (basic check)');
+}
+
+function printHealthResults(passed, warnings, issues) {
+  logger.section('Results');
+
+  if (passed.length > 0) {
+    logger.success(`Passed: ${passed.length}`);
+    passed.forEach(p => logger.dim(`  ✓ ${p}`));
+  }
+
+  if (warnings.length > 0) {
+    logger.warning(`Warnings: ${warnings.length}`);
+    warnings.forEach(w => logger.dim(`  ⚠ ${w}`));
+  }
+
+  if (issues.length > 0) {
+    logger.error(`Issues: ${issues.length}`);
+    issues.forEach(i => logger.dim(`  ✗ ${i}`));
+  }
+
+  // Overall health
+  const score = Math.round((passed.length / (passed.length + warnings.length + issues.length)) * 100);
+  logger.info('');
+  logger.bold(`Health Score: ${score}%`);
+
+  if (score >= 80) {
+    logger.success('Your project looks healthy!');
+  } else if (score >= 60) {
+    logger.warning('Some improvements needed');
+  } else {
+    logger.error('Several issues need attention');
+  }
+}
+
+async function autoFix(issues) {
+  logger.info('Attempting to auto-fix issues...');
+
+  // Auto-fix: create .gitignore if missing
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+  if (!(await fs.pathExists(gitignorePath))) {
+    await fs.writeFile(gitignorePath, `node_modules/\ndist/\nbuild/\n.env\n.env.local\n`);
+    logger.success('Created .gitignore');
+  }
+
+  // Auto-fix: create README if missing
+  const readmePath = path.join(process.cwd(), 'README.md');
+  if (!(await fs.pathExists(readmePath))) {
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    let name = 'Project';
+    if (await fs.pathExists(pkgPath)) {
+      const pkg = await fs.readJson(pkgPath);
+      name = pkg.name || name;
+    }
+    await fs.writeFile(readmePath, `# ${name}\n\nProject description here.\n`);
+    logger.success('Created README.md');
+  }
+}
+
+module.exports = healthCommand;

package/src/commands/info.js

@@ -0,0 +1,139 @@
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const logger = require('../utils/logger');
+const ProjectDetector = require('../utils/detector');
+
+const infoCommand = new Command('info')
+  .description('Show project and system information')
+  .option('-j, --json', 'Output as JSON', false)
+  .action(async (options) => {
+    logger.header('📋 Project Information');
+
+    try {
+      const detector = new ProjectDetector();
+      const projectInfo = await detector.detect();
+
+      const info = {
+        project: await getProjectInfo(projectInfo),
+        system: getSystemInfo(),
+        tools: await getToolsInfo(),
+        dependencies: await getDependencyInfo(),
+      };
+
+      if (options.json) {
+        console.log(JSON.stringify(info, null, 2));
+      } else {
+        printInfo(info);
+      }
+    } catch (error) {
+      logger.error(`Failed to get info: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function getProjectInfo(projectInfo) {
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  let pkg = {};
+  if (await fs.pathExists(pkgPath)) {
+    pkg = await fs.readJson(pkgPath);
+  }
+
+  return {
+    name: pkg.name || 'Unknown',
+    version: pkg.version || '1.0.0',
+    description: pkg.description || '',
+    framework: projectInfo.framework?.name || 'Unknown',
+    type: projectInfo.type || 'Unknown',
+    bundler: projectInfo.bundler || 'Unknown',
+    typescript: projectInfo.isTypeScript,
+    monorepo: projectInfo.isMonorepo,
+    nodeVersion: process.version,
+    path: process.cwd(),
+  };
+}
+
+function getSystemInfo() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    os: `${os.type()} ${os.release()}`,
+    cpus: os.cpus().length,
+    memory: `${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB`,
+    freeMemory: `${Math.round(os.freemem() / 1024 / 1024 / 1024)}GB`,
+    uptime: `${Math.round(os.uptime() / 3600)}h`,
+  };
+}
+
+async function getToolsInfo() {
+  const tools = {};
+
+  // Check for various tools
+  const toolChecks = [
+    { name: 'Node.js', command: 'node -v' },
+    { name: 'npm', command: 'npm -v' },
+    { name: 'yarn', command: 'yarn -v' },
+    { name: 'pnpm', command: 'pnpm -v' },
+    { name: 'Git', command: 'git --version' },
+    { name: 'Docker', command: 'docker --version' },
+    { name: 'Python', command: 'python --version' },
+  ];
+
+  for (const tool of toolChecks) {
+    try {
+      const { execSync } = require('child_process');
+      tools[tool.name] = execSync(tool.command, { encoding: 'utf8' }).trim();
+    } catch {
+      tools[tool.name] = 'Not installed';
+    }
+  }
+
+  return tools;
+}
+
+async function getDependencyInfo() {
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (!(await fs.pathExists(pkgPath))) {
+    return { dependencies: 0, devDependencies: 0 };
+  }
+
+  const pkg = await fs.readJson(pkgPath);
+  return {
+    dependencies: Object.keys(pkg.dependencies || {}).length,
+    devDependencies: Object.keys(pkg.devDependencies || {}).length,
+    scripts: Object.keys(pkg.scripts || {}).length,
+  };
+}
+
+function printInfo(info) {
+  logger.section('Project');
+  logger.dim(`  Name: ${info.project.name}`);
+  logger.dim(`  Version: ${info.project.version}`);
+  logger.dim(`  Framework: ${info.project.framework}`);
+  logger.dim(`  Type: ${info.project.type}`);
+  logger.dim(`  Bundler: ${info.project.bundler}`);
+  logger.dim(`  TypeScript: ${info.project.typescript ? '✓' : '✗'}`);
+  logger.dim(`  Monorepo: ${info.project.monorepo ? '✓' : '✗'}`);
+
+  logger.section('System');
+  logger.dim(`  Platform: ${info.system.platform}`);
+  logger.dim(`  Architecture: ${info.system.arch}`);
+  logger.dim(`  OS: ${info.system.os}`);
+  logger.dim(`  CPUs: ${info.system.cpus}`);
+  logger.dim(`  Memory: ${info.system.memory}`);
+  logger.dim(`  Free Memory: ${info.system.freeMemory}`);
+
+  logger.section('Tools');
+  for (const [name, version] of Object.entries(info.tools)) {
+    const status = version === 'Not installed' ? '✗' : '✓';
+    logger.dim(`  ${name}: ${version} ${status}`);
+  }
+
+  logger.section('Dependencies');
+  logger.dim(`  Production: ${info.dependencies.dependencies}`);
+  logger.dim(`  Development: ${info.dependencies.devDependencies}`);
+  logger.dim(`  Scripts: ${info.dependencies.scripts}`);
+}
+
+module.exports = infoCommand;