create-qa-architect 5.0.6 → 5.3.1

package/lib/quality-tools-generator.js

@@ -0,0 +1,495 @@
+/**
+ * Quality Tools Generator
+ * Generates configuration for advanced quality tools:
+ * - Lighthouse CI (performance, accessibility, SEO, best practices)
+ * - Bundle size limits (size-limit)
+ * - axe-core accessibility testing
+ * - Conventional commits (commitlint)
+ * - Coverage thresholds
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * Generate Lighthouse CI configuration
+ * @param {Object} options - Configuration options
+ * @param {string} options.projectPath - Path to project
+ * @param {boolean} options.hasThresholds - Whether to include score thresholds (Pro)
+ * @param {string} options.collectUrl - URL to audit (defaults to http://localhost:3000)
+ * @returns {string} lighthouserc.js content
+ */
+function generateLighthouseConfig(options = {}) {
+  const {
+    hasThresholds = false,
+    collectUrl = 'http://localhost:3000',
+    staticDistDir = null,
+  } = options
+
+  const collectConfig = staticDistDir
+    ? `staticDistDir: '${staticDistDir}',`
+    : `url: ['${collectUrl}'],
+      startServerCommand: 'npm run start',
+      startServerReadyPattern: 'ready|listening|started',
+      startServerReadyTimeout: 30000,`
+
+  const assertConfig = hasThresholds
+    ? `
+    assert: {
+      preset: 'lighthouse:recommended',
+      assertions: {
+        // Performance
+        'first-contentful-paint': ['warn', { maxNumericValue: 2000 }],
+        'largest-contentful-paint': ['error', { maxNumericValue: 2500 }],
+        'cumulative-layout-shift': ['error', { maxNumericValue: 0.1 }],
+        'total-blocking-time': ['warn', { maxNumericValue: 300 }],
+
+        // Categories (0-1 scale)
+        'categories:performance': ['warn', { minScore: 0.8 }],
+        'categories:accessibility': ['error', { minScore: 0.9 }],
+        'categories:best-practices': ['warn', { minScore: 0.9 }],
+        'categories:seo': ['warn', { minScore: 0.9 }],
+
+        // Allow some common warnings
+        'unsized-images': 'off',
+        'uses-responsive-images': 'off',
+      },
+    },`
+    : `
+    assert: {
+      // Basic assertions for Free tier - just warnings, no failures
+      assertions: {
+        'categories:accessibility': ['warn', { minScore: 0.7 }],
+        'categories:best-practices': ['warn', { minScore: 0.7 }],
+      },
+    },`
+
+  return `module.exports = {
+  ci: {
+    collect: {
+      ${collectConfig}
+      numberOfRuns: 3,
+    },
+    upload: {
+      target: 'temporary-public-storage',
+    },${assertConfig}
+  },
+}
+`
+}
+
+/**
+ * Generate size-limit configuration for bundle size limits
+ * @param {Object} options - Configuration options
+ * @param {string} options.projectPath - Path to project
+ * @returns {Array} size-limit config array
+ */
+function generateSizeLimitConfig(options = {}) {
+  const { projectPath = process.cwd() } = options
+
+  // Detect build output paths
+  const possibleDists = ['dist', 'build', '.next', 'out', 'public']
+  let distDir = 'dist'
+
+  for (const dir of possibleDists) {
+    if (fs.existsSync(path.join(projectPath, dir))) {
+      distDir = dir
+      break
+    }
+  }
+
+  // Detect if it's a Next.js app
+  const isNextJS =
+    fs.existsSync(path.join(projectPath, 'next.config.js')) ||
+    fs.existsSync(path.join(projectPath, 'next.config.mjs'))
+
+  if (isNextJS) {
+    return [
+      {
+        path: '.next/static/**/*.js',
+        limit: '300 kB',
+        webpack: false,
+      },
+    ]
+  }
+
+  return [
+    {
+      path: `${distDir}/**/*.js`,
+      limit: '250 kB',
+    },
+    {
+      path: `${distDir}/**/*.css`,
+      limit: '50 kB',
+    },
+  ]
+}
+
+/**
+ * Generate commitlint configuration for conventional commits
+ * @returns {string} commitlint.config.js content
+ */
+function generateCommitlintConfig() {
+  return `module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    // Type must be one of the conventional types
+    'type-enum': [
+      2,
+      'always',
+      [
+        'feat',     // New feature
+        'fix',      // Bug fix
+        'docs',     // Documentation only
+        'style',    // Formatting, no code change
+        'refactor', // Code change that neither fixes a bug nor adds a feature
+        'perf',     // Performance improvement
+        'test',     // Adding tests
+        'build',    // Build system or external dependencies
+        'ci',       // CI configuration
+        'chore',    // Maintenance tasks
+        'revert',   // Revert a previous commit
+      ],
+    ],
+    // Subject line max length
+    'subject-max-length': [2, 'always', 100],
+    // Subject must not be empty
+    'subject-empty': [2, 'never'],
+    // Type must not be empty
+    'type-empty': [2, 'never'],
+  },
+}
+`
+}
+
+/**
+ * Generate commit-msg hook content for commitlint
+ * @returns {string} commit-msg hook content
+ */
+function generateCommitMsgHook() {
+  return `#!/bin/sh
+npx --no -- commitlint --edit "$1"
+`
+}
+
+/**
+ * Generate vitest coverage thresholds configuration
+ * @param {Object} options - Configuration options
+ * @param {number} options.lines - Line coverage threshold (default: 70)
+ * @param {number} options.functions - Function coverage threshold (default: 70)
+ * @param {number} options.branches - Branch coverage threshold (default: 60)
+ * @param {number} options.statements - Statement coverage threshold (default: 70)
+ * @returns {Object} Coverage threshold config object
+ */
+function generateCoverageThresholds(options = {}) {
+  const { lines = 70, functions = 70, branches = 60, statements = 70 } = options
+
+  return {
+    lines,
+    functions,
+    branches,
+    statements,
+  }
+}
+
+/**
+ * Generate vitest.config.ts/js with coverage thresholds
+ * @param {Object} options - Configuration options
+ * @returns {string} vitest.config content
+ */
+function generateVitestConfigWithCoverage(options = {}) {
+  const { typescript = false, thresholds = {} } = options
+  const coverageThresholds = generateCoverageThresholds(thresholds)
+
+  const importStatement = typescript
+    ? "import { defineConfig } from 'vitest/config'"
+    : "const { defineConfig } = require('vitest/config')"
+  const exportStatement = typescript ? 'export default' : 'module.exports ='
+
+  return `${importStatement}
+
+${exportStatement} defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.{js,ts}', 'src/**/*.test.{js,ts}'],
+    exclude: ['node_modules', 'dist', 'build'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html', 'lcov'],
+      exclude: [
+        'node_modules/**',
+        'tests/**',
+        '**/*.test.{js,ts}',
+        '**/*.config.{js,ts,mjs}',
+        'coverage/**',
+        'dist/**',
+        'build/**',
+      ],
+      thresholds: {
+        lines: ${coverageThresholds.lines},
+        functions: ${coverageThresholds.functions},
+        branches: ${coverageThresholds.branches},
+        statements: ${coverageThresholds.statements},
+      },
+    },
+  },
+})
+`
+}
+
+/**
+ * Generate axe-core accessibility test setup
+ * @returns {string} Accessibility test file content
+ */
+function generateAxeTestSetup() {
+  return `/**
+ * Accessibility Testing with axe-core
+ *
+ * This file sets up automated accessibility testing using axe-core.
+ * It can be run as part of your test suite or CI pipeline.
+ *
+ * Usage:
+ *   npm run test:a11y
+ *
+ * For manual testing, use the browser extension:
+ *   https://www.deque.com/axe/browser-extensions/
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+
+// For component testing, use @axe-core/react or @axe-core/playwright
+// This example uses puppeteer for full page testing
+
+let browser
+
+describe('Accessibility Tests', () => {
+  beforeAll(async () => {
+    // If using puppeteer for E2E accessibility testing:
+    // const puppeteer = require('puppeteer')
+    // browser = await puppeteer.launch()
+    // const page = await browser.newPage()
+
+    // For now, this is a placeholder that passes
+    // Replace with actual implementation based on your framework
+  })
+
+  afterAll(async () => {
+    if (browser) {
+      await browser.close()
+    }
+  })
+
+  it.skip('should have no critical accessibility violations on homepage', async () => {
+    // Example with puppeteer + @axe-core/puppeteer:
+    // const { AxePuppeteer } = require('@axe-core/puppeteer')
+    // await page.goto('http://localhost:3000')
+    // const results = await new AxePuppeteer(page).analyze()
+    // expect(results.violations.filter(v => v.impact === 'critical')).toHaveLength(0)
+    expect(true).toBe(true)
+  })
+
+  it.skip('should have proper heading hierarchy', async () => {
+    // Implement heading hierarchy check
+    expect(true).toBe(true)
+  })
+
+  it.skip('should have sufficient color contrast', async () => {
+    // Implement color contrast check
+    expect(true).toBe(true)
+  })
+
+  it.skip('should have accessible form labels', async () => {
+    // Implement form label check
+    expect(true).toBe(true)
+  })
+})
+
+/**
+ * Helper function to run axe-core on a page
+ * @param {Object} page - Puppeteer/Playwright page object
+ * @returns {Promise<Object>} axe results
+ */
+export async function runAxeOnPage(page) {
+  // Inject axe-core into the page
+  await page.addScriptTag({
+    path: require.resolve('axe-core'),
+  })
+
+  // Run axe
+  const results = await page.evaluate(async () => {
+    // eslint-disable-next-line no-undef
+    return await axe.run()
+  })
+
+  return results
+}
+
+/**
+ * Filter axe violations by impact level
+ * @param {Array} violations - axe violations array
+ * @param {Array} levels - Impact levels to include ['critical', 'serious', 'moderate', 'minor']
+ * @returns {Array} Filtered violations
+ */
+export function filterByImpact(violations, levels = ['critical', 'serious']) {
+  return violations.filter(v => levels.includes(v.impact))
+}
+`
+}
+
+/**
+ * Write Lighthouse CI config to project
+ * @param {string} projectPath - Path to project
+ * @param {Object} options - Options for config generation
+ */
+function writeLighthouseConfig(projectPath, options = {}) {
+  const configPath = path.join(projectPath, 'lighthouserc.js')
+  const config = generateLighthouseConfig(options)
+  fs.writeFileSync(configPath, config)
+  return configPath
+}
+
+/**
+ * Write size-limit config to package.json
+ * @param {string} projectPath - Path to project
+ * @param {Object} options - Options for config generation
+ */
+function writeSizeLimitConfig(projectPath, options = {}) {
+  const packageJsonPath = path.join(projectPath, 'package.json')
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('package.json not found')
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+  packageJson['size-limit'] = generateSizeLimitConfig({
+    projectPath,
+    ...options,
+  })
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n')
+  return packageJsonPath
+}
+
+/**
+ * Write commitlint config to project
+ * @param {string} projectPath - Path to project
+ */
+function writeCommitlintConfig(projectPath) {
+  const configPath = path.join(projectPath, 'commitlint.config.js')
+  const config = generateCommitlintConfig()
+  fs.writeFileSync(configPath, config)
+  return configPath
+}
+
+/**
+ * Write commit-msg hook for commitlint
+ * @param {string} projectPath - Path to project
+ */
+function writeCommitMsgHook(projectPath) {
+  const huskyDir = path.join(projectPath, '.husky')
+  if (!fs.existsSync(huskyDir)) {
+    fs.mkdirSync(huskyDir, { recursive: true })
+  }
+
+  const hookPath = path.join(huskyDir, 'commit-msg')
+  const hook = generateCommitMsgHook()
+  fs.writeFileSync(hookPath, hook)
+  fs.chmodSync(hookPath, 0o755)
+  return hookPath
+}
+
+/**
+ * Write axe test setup to project
+ * @param {string} projectPath - Path to project
+ * @param {Object} options - Options for test generation
+ */
+function writeAxeTestSetup(projectPath, options = {}) {
+  const testsDir = path.join(projectPath, 'tests')
+  if (!fs.existsSync(testsDir)) {
+    fs.mkdirSync(testsDir, { recursive: true })
+  }
+
+  const testPath = path.join(testsDir, 'accessibility.test.js')
+  const content = generateAxeTestSetup(options)
+  fs.writeFileSync(testPath, content)
+  return testPath
+}
+
+/**
+ * Get dev dependencies for quality tools
+ * @param {Object} features - Which features to include
+ * @returns {Object} Dev dependencies object
+ */
+function getQualityToolsDependencies(features = {}) {
+  const deps = {}
+
+  if (features.lighthouse) {
+    deps['@lhci/cli'] = '^0.14.0'
+  }
+
+  if (features.sizeLimit) {
+    deps['size-limit'] = '^11.0.0'
+    deps['@size-limit/file'] = '^11.0.0'
+  }
+
+  if (features.commitlint) {
+    deps['@commitlint/cli'] = '^19.0.0'
+    deps['@commitlint/config-conventional'] = '^19.0.0'
+  }
+
+  if (features.axeCore) {
+    deps['axe-core'] = '^4.10.0'
+  }
+
+  return deps
+}
+
+/**
+ * Get npm scripts for quality tools
+ * @param {Object} features - Which features to include
+ * @returns {Object} Scripts object
+ */
+function getQualityToolsScripts(features = {}) {
+  const scripts = {}
+
+  if (features.lighthouse) {
+    scripts['lighthouse:ci'] = 'lhci autorun'
+    scripts['lighthouse:upload'] = 'lhci upload'
+  }
+
+  if (features.sizeLimit) {
+    scripts['size'] = 'size-limit'
+    scripts['size:why'] = 'size-limit --why'
+  }
+
+  if (features.axeCore) {
+    scripts['test:a11y'] = 'vitest run tests/accessibility.test.js'
+  }
+
+  if (features.coverage) {
+    scripts['test:coverage'] = 'vitest run --coverage'
+    scripts['test:coverage:check'] =
+      'vitest run --coverage --coverage.thresholds.lines=70 --coverage.thresholds.functions=70'
+  }
+
+  return scripts
+}
+
+module.exports = {
+  // Config generators
+  generateLighthouseConfig,
+  generateSizeLimitConfig,
+  generateCommitlintConfig,
+  generateCommitMsgHook,
+  generateCoverageThresholds,
+  generateVitestConfigWithCoverage,
+  generateAxeTestSetup,
+  // Writers
+  writeLighthouseConfig,
+  writeSizeLimitConfig,
+  writeCommitlintConfig,
+  writeCommitMsgHook,
+  writeAxeTestSetup,
+  // Helpers
+  getQualityToolsDependencies,
+  getQualityToolsScripts,
+}

package/lib/result-types.js

@@ -0,0 +1,112 @@
+/**
+ * DR25 fix: Standard result type helpers for consistent API across modules
+ *
+ * This module provides standard result builders to ensure consistency across
+ * all modules in the codebase. Use these instead of ad-hoc result objects.
+ *
+ * STANDARD PATTERNS:
+ *
+ * 1. Success/failure operations (file I/O, validation, etc.):
+ *    { success: true, data?: any }
+ *    { success: false, error: string, details?: any }
+ *
+ * 2. Validation results:
+ *    { valid: true, data?: any }
+ *    { valid: false, error: string, details?: any }
+ *
+ * 3. Query results:
+ *    - Found: return data directly or { found: true, data }
+ *    - Not found: return null or { found: false }
+ *
+ * MIGRATION STATUS:
+ * - lib/licensing.js: Uses mixed patterns (being migrated)
+ * - lib/license-validator.js: Uses valid/error pattern
+ * - webhook-handler.js: Uses success/error pattern
+ * - lib/error-reporter.js: Uses success/error pattern
+ * - lib/template-loader.js: Uses success/errors array pattern
+ *
+ * @module result-types
+ */
+
+'use strict'
+
+/**
+ * Create a successful operation result
+ * @param {any} data - Optional data to include
+ * @returns {{ success: true, data?: any }}
+ */
+function success(data = null) {
+  const result = { success: true }
+  if (data !== null && data !== undefined) {
+    result.data = data
+  }
+  return result
+}
+
+/**
+ * Create a failed operation result
+ * @param {string} error - Error message
+ * @param {any} details - Optional error details
+ * @returns {{ success: false, error: string, details?: any }}
+ */
+function failure(error, details = null) {
+  const result = { success: false, error }
+  if (details !== null && details !== undefined) {
+    result.details = details
+  }
+  return result
+}
+
+/**
+ * Create a successful validation result
+ * @param {any} data - Optional validated data
+ * @returns {{ valid: true, data?: any }}
+ */
+function valid(data = null) {
+  const result = { valid: true }
+  if (data !== null && data !== undefined) {
+    result.data = data
+  }
+  return result
+}
+
+/**
+ * Create a failed validation result
+ * @param {string} error - Validation error message
+ * @param {any} details - Optional error details
+ * @returns {{ valid: false, error: string, details?: any }}
+ */
+function invalid(error, details = null) {
+  const result = { valid: false, error }
+  if (details !== null && details !== undefined) {
+    result.details = details
+  }
+  return result
+}
+
+/**
+ * Check if a result indicates success (works with both patterns)
+ * @param {object} result - Result object to check
+ * @returns {boolean} True if successful or valid
+ */
+function isSuccess(result) {
+  return result && (result.success === true || result.valid === true)
+}
+
+/**
+ * Check if a result indicates failure (works with both patterns)
+ * @param {object} result - Result object to check
+ * @returns {boolean} True if failed or invalid
+ */
+function isFailure(result) {
+  return result && (result.success === false || result.valid === false)
+}
+
+module.exports = {
+  success,
+  failure,
+  valid,
+  invalid,
+  isSuccess,
+  isFailure,
+}

package/lib/security-enhancements.js

@@ -10,7 +10,7 @@ const path = require('path')
  * Generate enhanced security configuration
  * Makes security scanning the default, not optional
  */
-function generateSecurityFirstConfig(_projectPath = '.') {
+function generateSecurityFirstConfig() {
   const securityConfig = {
     // Secret scanning configuration
     gitleaks: {

package/lib/smart-strategy-generator.js

@@ -154,17 +154,38 @@ const PROJECT_CONFIGS = {
 
 /**
  * Read package.json from project path
+ * DR22 fix: Differentiate between missing file vs. read/parse errors
  */
 function readPackageJson(projectPath) {
+  const pkgPath = path.join(projectPath, 'package.json')
+
+  // File doesn't exist - expected for non-JS projects
+  if (!fs.existsSync(pkgPath)) {
+    return null
+  }
+
   try {
-    const pkgPath = path.join(projectPath, 'package.json')
-    if (fs.existsSync(pkgPath)) {
-      return JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+    const content = fs.readFileSync(pkgPath, 'utf8')
+    return JSON.parse(content)
+  } catch (error) {
+    // DR22 fix: Provide specific error messages for different failure types
+    if (error instanceof SyntaxError) {
+      console.error(`❌ package.json has invalid JSON syntax: ${error.message}`)
+      console.error(`   File: ${pkgPath}`)
+      console.error('   Please fix JSON syntax errors before continuing')
+    } else if (error.code === 'EACCES') {
+      console.error(`❌ Permission denied reading package.json: ${pkgPath}`)
+      console.error('   Check file permissions and try again')
+    } else {
+      console.error(
+        `❌ Unexpected error reading package.json: ${error.message}`
+      )
+      if (process.env.DEBUG) {
+        console.error(error.stack)
+      }
     }
-  } catch {
-    // Ignore errors
+    return null
   }
-  return null
 }
 
 /**
@@ -321,9 +342,7 @@ fi
 /**
  * Add test tier scripts to package.json
  */
-function getTestTierScripts(_projectType) {
-  // const config = PROJECT_CONFIGS[projectType] || PROJECT_CONFIGS.default
-
+function getTestTierScripts() {
   return {
     'test:fast': 'vitest run --reporter=basic --coverage=false',
     'test:medium':