create-qa-architect 5.0.0

package/lib/smart-strategy-generator.js

@@ -0,0 +1,344 @@
+/**
+ * Smart Test Strategy Generator
+ * Generates project-specific smart test strategy scripts
+ * Premium feature (Pro/Team/Enterprise tiers)
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * Project type configurations with risk patterns and test commands
+ */
+const PROJECT_CONFIGS = {
+  // CLI tools (like create-qa-architect)
+  cli: {
+    name: 'CLI Tool',
+    highRiskRegex: 'setup\\.js|lib/.*|templates/.*|config/.*|bin/.*',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || npm run test 2>/dev/null || npm test',
+      medium:
+        'npm run test:medium 2>/dev/null || npm run test:fast 2>/dev/null || npm test',
+      fast: 'npm run test:fast 2>/dev/null || npm run test:unit 2>/dev/null || npm test',
+      minimal: 'npm run lint && npm run format:check',
+    },
+    detection: projectPath => {
+      const pkg = readPackageJson(projectPath)
+      return pkg?.bin || pkg?.scripts?.setup
+    },
+  },
+
+  // Web applications (Next.js, React, Vue, etc.)
+  webapp: {
+    name: 'Web Application',
+    highRiskRegex:
+      'auth|payment|security|crypto|api/|pages/api/|app/api/|middleware',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || (npm test && npm run test:e2e 2>/dev/null)',
+      medium:
+        'npm run test:medium 2>/dev/null || npm run test -- --testPathIgnorePatterns=e2e',
+      fast: 'npm run test:fast 2>/dev/null || npm run test -- --watch=false --coverage=false',
+      minimal: 'npm run lint && npm run format:check',
+    },
+    detection: projectPath => {
+      const pkg = readPackageJson(projectPath)
+      const deps = { ...pkg?.dependencies, ...pkg?.devDependencies }
+      return (
+        deps?.next ||
+        deps?.react ||
+        deps?.vue ||
+        deps?.['@angular/core'] ||
+        deps?.svelte
+      )
+    },
+  },
+
+  // SaaS applications (payment, billing, auth heavy)
+  saas: {
+    name: 'SaaS Application',
+    highRiskRegex:
+      'auth|payment|billing|stripe|subscription|prisma/schema|middleware|webhook',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || (npm test && npm run security:audit 2>/dev/null)',
+      medium: 'npm run test:medium 2>/dev/null || npm test',
+      fast: 'npm run test:fast 2>/dev/null || npm run test:unit 2>/dev/null || npm test',
+      minimal: 'npm run lint && npm run format:check',
+    },
+    detection: projectPath => {
+      const pkg = readPackageJson(projectPath)
+      const deps = { ...pkg?.dependencies, ...pkg?.devDependencies }
+      return deps?.stripe || deps?.['@stripe/stripe-js'] || deps?.prisma
+    },
+  },
+
+  // API services (Express, Fastify, etc.)
+  api: {
+    name: 'API Service',
+    highRiskRegex: 'routes/|controllers/|middleware/|auth|security|database',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || npm run test:integration 2>/dev/null || npm test',
+      medium:
+        'npm run test:medium 2>/dev/null || npm run test -- --testPathIgnorePatterns=integration',
+      fast: 'npm run test:fast 2>/dev/null || npm run test:unit 2>/dev/null || npm test',
+      minimal: 'npm run lint && npm run format:check',
+    },
+    detection: projectPath => {
+      const pkg = readPackageJson(projectPath)
+      const deps = { ...pkg?.dependencies, ...pkg?.devDependencies }
+      return (
+        deps?.express ||
+        deps?.fastify ||
+        deps?.koa ||
+        deps?.hapi ||
+        deps?.restify
+      )
+    },
+  },
+
+  // Library/Package
+  library: {
+    name: 'Library/Package',
+    highRiskRegex: 'src/|lib/|index\\.(js|ts)|package\\.json',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || (npm test && npm run build 2>/dev/null)',
+      medium: 'npm run test:medium 2>/dev/null || npm test',
+      fast: 'npm run test:fast 2>/dev/null || npm run test:unit 2>/dev/null || npm test',
+      minimal: 'npm run lint && npm run format:check',
+    },
+    detection: projectPath => {
+      const pkg = readPackageJson(projectPath)
+      return pkg?.main || pkg?.module || pkg?.exports
+    },
+  },
+
+  // Documentation project
+  docs: {
+    name: 'Documentation',
+    highRiskRegex: 'guides/security|guides/deployment|setup-instructions',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || (npm run lint && npm run link:check 2>/dev/null)',
+      medium:
+        'npm run test:medium 2>/dev/null || npm run lint && npm run spell:check 2>/dev/null',
+      fast: 'npm run test:fast 2>/dev/null || npm run lint',
+      minimal: 'npm run lint 2>/dev/null || npx markdownlint "**/*.md"',
+    },
+    detection: projectPath => {
+      const hasReadme = fs.existsSync(path.join(projectPath, 'README.md'))
+      const hasDocs = fs.existsSync(path.join(projectPath, 'docs'))
+      const pkg = readPackageJson(projectPath)
+      return hasDocs && !pkg?.dependencies && hasReadme
+    },
+  },
+
+  // Default fallback
+  default: {
+    name: 'General Project',
+    highRiskRegex: 'src/|lib/|config/|package\\.json',
+    testCommands: {
+      comprehensive:
+        'npm run test:comprehensive 2>/dev/null || npm test 2>/dev/null || echo "No test script found"',
+      medium:
+        'npm run test:medium 2>/dev/null || npm test 2>/dev/null || echo "No test script found"',
+      fast: 'npm run test:fast 2>/dev/null || npm run test:unit 2>/dev/null || npm test 2>/dev/null || echo "No test script found"',
+      minimal: 'npm run lint && npm run format:check',
+    },
+    detection: () => true, // Fallback always matches
+  },
+}
+
+/**
+ * Read package.json from project path
+ */
+function readPackageJson(projectPath) {
+  try {
+    const pkgPath = path.join(projectPath, 'package.json')
+    if (fs.existsSync(pkgPath)) {
+      return JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null
+}
+
+/**
+ * Detect project type based on dependencies and structure
+ */
+function detectProjectType(projectPath) {
+  // Check each project type in priority order
+  const typeOrder = ['saas', 'webapp', 'api', 'cli', 'library', 'docs']
+
+  for (const type of typeOrder) {
+    const config = PROJECT_CONFIGS[type]
+    if (config.detection(projectPath)) {
+      return type
+    }
+  }
+
+  return 'default'
+}
+
+/**
+ * Generate smart test strategy script for a project
+ */
+function generateSmartStrategy(options = {}) {
+  const {
+    projectPath = process.cwd(),
+    projectName = path.basename(projectPath),
+    projectType = null, // Auto-detect if not provided
+    customHighRiskRegex = null,
+    customTestCommands = null,
+  } = options
+
+  // Detect or use provided project type
+  const detectedType = projectType || detectProjectType(projectPath)
+  const config = PROJECT_CONFIGS[detectedType] || PROJECT_CONFIGS.default
+
+  // Allow custom overrides
+  const highRiskRegex = customHighRiskRegex || config.highRiskRegex
+  const testCommands = { ...config.testCommands, ...customTestCommands }
+
+  // Read template
+  const templatePath = path.join(
+    __dirname,
+    '..',
+    'templates',
+    'scripts',
+    'smart-test-strategy.sh'
+  )
+
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Smart strategy template not found at ${templatePath}`)
+  }
+
+  let template = fs.readFileSync(templatePath, 'utf8')
+
+  // Replace placeholders
+  template = template.replace(/\{\{PROJECT_NAME\}\}/g, projectName)
+  template = template.replace(/\{\{HIGH_RISK_REGEX\}\}/g, highRiskRegex)
+  template = template.replace(
+    /\{\{HIGH_RISK_PATTERN\}\}/g,
+    `Project type: ${config.name}`
+  )
+  template = template.replace(
+    /\{\{TEST_COMPREHENSIVE\}\}/g,
+    testCommands.comprehensive
+  )
+  template = template.replace(/\{\{TEST_MEDIUM\}\}/g, testCommands.medium)
+  template = template.replace(/\{\{TEST_FAST\}\}/g, testCommands.fast)
+  template = template.replace(/\{\{TEST_MINIMAL\}\}/g, testCommands.minimal)
+  template = template.replace(
+    /\{\{COMPREHENSIVE_COMMAND\}\}/g,
+    `Runs: ${testCommands.comprehensive}`
+  )
+  template = template.replace(
+    /\{\{MEDIUM_COMMAND\}\}/g,
+    `Runs: ${testCommands.medium}`
+  )
+  template = template.replace(
+    /\{\{FAST_COMMAND\}\}/g,
+    `Runs: ${testCommands.fast}`
+  )
+  template = template.replace(
+    /\{\{MINIMAL_COMMAND\}\}/g,
+    `Runs: ${testCommands.minimal}`
+  )
+
+  return {
+    script: template,
+    projectType: detectedType,
+    projectTypeName: config.name,
+    highRiskRegex,
+    testCommands,
+  }
+}
+
+/**
+ * Write smart strategy script to project
+ */
+function writeSmartStrategy(projectPath, script) {
+  const scriptsDir = path.join(projectPath, 'scripts')
+  const scriptPath = path.join(scriptsDir, 'smart-test-strategy.sh')
+
+  // Create scripts directory if needed
+  if (!fs.existsSync(scriptsDir)) {
+    fs.mkdirSync(scriptsDir, { recursive: true })
+  }
+
+  // Write script
+  fs.writeFileSync(scriptPath, script)
+  fs.chmodSync(scriptPath, 0o755)
+
+  return scriptPath
+}
+
+/**
+ * Generate pre-push hook that uses smart strategy
+ */
+function generateSmartPrePushHook() {
+  return `#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+echo "🔍 Running smart pre-push validation..."
+
+# Check if smart test strategy script exists
+if [ -f "scripts/smart-test-strategy.sh" ]; then
+  bash scripts/smart-test-strategy.sh
+else
+  # Fallback to basic validation
+  echo "📝 Linting..."
+  npm run lint || {
+    echo "❌ Lint failed! Fix errors before pushing."
+    exit 1
+  }
+
+  echo "✨ Checking formatting..."
+  npm run format:check || {
+    echo "❌ Format check failed! Run 'npm run format' to fix."
+    exit 1
+  }
+
+  # Run tests if they exist
+  if node -e "const pkg=require('./package.json');process.exit(pkg.scripts.test?0:1)" 2>/dev/null; then
+    echo "🧪 Running tests..."
+    npm test || {
+      echo "❌ Tests failed! Fix failing tests before pushing."
+      exit 1
+    }
+  fi
+
+  echo "✅ Pre-push validation passed!"
+fi
+`
+}
+
+/**
+ * Add test tier scripts to package.json
+ */
+function getTestTierScripts(_projectType) {
+  // const config = PROJECT_CONFIGS[projectType] || PROJECT_CONFIGS.default
+
+  return {
+    'test:fast': 'vitest run --reporter=basic --coverage=false',
+    'test:medium':
+      'vitest run --reporter=basic --testPathIgnorePatterns=e2e,integration',
+    'test:comprehensive':
+      'vitest run && npm run lint && npm run format:check && npm run security:audit 2>/dev/null || true',
+    'test:smart': 'bash scripts/smart-test-strategy.sh',
+  }
+}
+
+module.exports = {
+  PROJECT_CONFIGS,
+  detectProjectType,
+  generateSmartStrategy,
+  writeSmartStrategy,
+  generateSmartPrePushHook,
+  getTestTierScripts,
+}

package/lib/telemetry.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+/**
+ * Telemetry module for usage tracking (opt-in only)
+ *
+ * Privacy principles:
+ * - Completely opt-in (ENV var or explicit flag)
+ * - No personal information collected (no paths, usernames, IPs)
+ * - Local storage only (no network calls)
+ * - Easy to inspect and delete
+ * - Anonymous session IDs
+ *
+ * Data collected:
+ * - Event types (setup_started, setup_completed, setup_failed)
+ * - Timestamps
+ * - Template selection (custom vs default)
+ * - Features used (validate, deps, dry-run, interactive)
+ * - Node version and OS platform
+ * - Error types (if failed)
+ * - Setup duration
+ */
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+const { REPORTING_LIMITS } = require('../config/constants')
+
+const getTelemetryDir = () =>
+  process.env.QAA_TELEMETRY_DIR ||
+  path.join(os.homedir(), '.create-qa-architect')
+const getTelemetryFile = () => path.join(getTelemetryDir(), 'telemetry.json')
+const TELEMETRY_FILE = getTelemetryFile()
+const MAX_EVENTS = REPORTING_LIMITS.MAX_TELEMETRY_EVENTS
+
+/**
+ * Check if telemetry is enabled
+ * Opt-in via environment variable or explicit flag
+ */
+function isTelemetryEnabled() {
+  // Check environment variable
+  const envEnabled =
+    process.env.QAA_TELEMETRY === 'true' || process.env.QAA_TELEMETRY === '1'
+
+  // Check config file (future: allow persistent opt-in)
+  // For now, only ENV var
+
+  return envEnabled
+}
+
+/**
+ * Generate anonymous session ID
+ */
+function generateSessionId() {
+  return crypto.randomBytes(16).toString('hex')
+}
+
+/**
+ * Ensure telemetry directory exists
+ */
+function ensureTelemetryDir() {
+  const dir = getTelemetryDir()
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  }
+}
+
+/**
+ * Load existing telemetry data
+ */
+function loadTelemetryData() {
+  try {
+    const file = getTelemetryFile()
+    if (fs.existsSync(file)) {
+      const data = fs.readFileSync(file, 'utf8')
+      return JSON.parse(data)
+    }
+  } catch {
+    // If corrupted, start fresh
+    console.warn('⚠️  Telemetry data corrupted, starting fresh')
+  }
+
+  return {
+    version: 1,
+    events: [],
+  }
+}
+
+/**
+ * Save telemetry data (with rotation)
+ */
+function saveTelemetryData(data) {
+  try {
+    ensureTelemetryDir()
+    const file = getTelemetryFile()
+
+    // Rotate: keep only last MAX_EVENTS
+    if (data.events.length > MAX_EVENTS) {
+      data.events = data.events.slice(-MAX_EVENTS)
+    }
+
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), {
+      mode: 0o600, // Owner read/write only
+    })
+  } catch (error) {
+    // Silently fail - telemetry should never break the tool
+    // Only log in debug mode
+    if (process.env.DEBUG) {
+      console.error('Telemetry save error:', error.message)
+    }
+  }
+}
+
+/**
+ * Record a telemetry event
+ *
+ * @param {string} eventType - Event type (setup_started, setup_completed, setup_failed)
+ * @param {object} metadata - Additional event metadata
+ * @param {string} sessionId - Session ID for grouping related events
+ */
+function recordEvent(eventType, metadata = {}, sessionId = null) {
+  if (!isTelemetryEnabled()) {
+    return
+  }
+
+  try {
+    const data = loadTelemetryData()
+
+    const event = {
+      eventType,
+      timestamp: new Date().toISOString(),
+      sessionId: sessionId || generateSessionId(),
+      metadata: {
+        nodeVersion: process.version,
+        platform: os.platform(),
+        arch: os.arch(),
+        ...metadata,
+      },
+    }
+
+    data.events.push(event)
+    saveTelemetryData(data)
+  } catch (error) {
+    // Silently fail - telemetry should never break the tool
+    if (process.env.DEBUG) {
+      console.error('Telemetry record error:', error.message)
+    }
+  }
+}
+
+/**
+ * Create a telemetry session for tracking related events
+ */
+class TelemetrySession {
+  constructor() {
+    this.sessionId = generateSessionId()
+    this.startTime = Date.now()
+    this.enabled = isTelemetryEnabled()
+    this.telemetryFile = getTelemetryFile()
+  }
+
+  /**
+   * Record setup start event
+   */
+  recordStart(metadata = {}) {
+    if (!this.enabled) return
+
+    recordEvent(
+      'setup_started',
+      {
+        ...metadata,
+        timestamp: new Date(this.startTime).toISOString(),
+      },
+      this.sessionId
+    )
+  }
+
+  /**
+   * Record setup completion event
+   */
+  recordComplete(metadata = {}) {
+    if (!this.enabled) return
+
+    const duration = Date.now() - this.startTime
+
+    recordEvent(
+      'setup_completed',
+      {
+        ...metadata,
+        durationMs: duration,
+        durationSec: Math.round(duration / 1000),
+      },
+      this.sessionId
+    )
+  }
+
+  /**
+   * Record setup failure event
+   */
+  recordFailure(error, metadata = {}) {
+    if (!this.enabled) return
+
+    const duration = Date.now() - this.startTime
+
+    recordEvent(
+      'setup_failed',
+      {
+        ...metadata,
+        errorType: error?.constructor?.name || 'Unknown',
+        errorMessage: error?.message || 'Unknown error',
+        durationMs: duration,
+      },
+      this.sessionId
+    )
+  }
+
+  /**
+   * Record validation event
+   */
+  recordValidation(validationType, passed, metadata = {}) {
+    if (!this.enabled) return
+
+    recordEvent(
+      'validation',
+      {
+        ...metadata,
+        validationType,
+        passed,
+      },
+      this.sessionId
+    )
+  }
+}
+
+/**
+ * Get telemetry statistics (for debugging/testing)
+ */
+function getTelemetryStats() {
+  const data = loadTelemetryData()
+
+  const stats = {
+    totalEvents: data.events.length,
+    eventTypes: {},
+    platforms: {},
+    nodeVersions: {},
+    recentEvents: data.events.slice(-10),
+  }
+
+  data.events.forEach(event => {
+    // Count event types
+    stats.eventTypes[event.eventType] =
+      (stats.eventTypes[event.eventType] || 0) + 1
+
+    // Count platforms
+    const platform = event.metadata?.platform || 'unknown'
+    stats.platforms[platform] = (stats.platforms[platform] || 0) + 1
+
+    // Count Node versions
+    const nodeVersion = event.metadata?.nodeVersion || 'unknown'
+    stats.nodeVersions[nodeVersion] = (stats.nodeVersions[nodeVersion] || 0) + 1
+  })
+
+  return stats
+}
+
+/**
+ * Clear all telemetry data
+ */
+function clearTelemetry() {
+  try {
+    if (fs.existsSync(TELEMETRY_FILE)) {
+      fs.unlinkSync(TELEMETRY_FILE)
+      return true
+    }
+    return false
+  } catch (error) {
+    console.error('Failed to clear telemetry:', error.message)
+    return false
+  }
+}
+
+/**
+ * Show telemetry status and opt-in instructions
+ */
+function showTelemetryStatus() {
+  const enabled = isTelemetryEnabled()
+
+  console.log('\n📊 Telemetry Status')
+  console.log('─'.repeat(50))
+  console.log(
+    `Status: ${enabled ? '✅ Enabled' : '❌ Disabled (opt-in required)'}`
+  )
+
+  if (enabled) {
+    const stats = getTelemetryStats()
+    console.log(`Events collected: ${stats.totalEvents}`)
+    console.log(`Storage: ${TELEMETRY_FILE}`)
+  } else {
+    console.log('\nTo enable telemetry (opt-in):')
+    console.log('  export QAA_TELEMETRY=true')
+    console.log('  # or add to ~/.bashrc or ~/.zshrc')
+    console.log('\nWhy enable telemetry?')
+    console.log('  - Helps improve the tool based on real usage patterns')
+    console.log('  - All data stays local (no network calls)')
+    console.log('  - No personal information collected')
+    console.log(
+      '  - Easy to inspect: cat ~/.create-qa-architect/telemetry.json'
+    )
+    console.log('  - Easy to delete: rm ~/.create-qa-architect/telemetry.json')
+  }
+
+  console.log('─'.repeat(50))
+}
+
+module.exports = {
+  isTelemetryEnabled,
+  recordEvent,
+  TelemetrySession,
+  getTelemetryStats,
+  clearTelemetry,
+  showTelemetryStatus,
+  TELEMETRY_FILE,
+}