@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/scripts/generate-test-data.js

@@ -0,0 +1,557 @@
+#!/usr/bin/env node
+
+/**
+ * Mock Data Generator for Learning Analytics Dashboard Testing
+ *
+ * Generates realistic learning data for testing the Analytics Dashboard
+ * with various scenarios: empty state, new user, active user, power user, edge cases
+ *
+ * Usage: node scripts/generate-test-data.js <scenario>
+ * Scenarios: empty, new, active, power, edge
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+
+// Test data output path
+const OUTPUT_DIR = path.join(process.cwd(), '.adf', 'learning');
+
+// Sample questions database
+const QUESTIONS = {
+  overview: [
+    { id: 'q_core_purpose', text: 'What is the core purpose of this project?', category: 'overview' },
+    { id: 'q_target_users', text: 'Who are the target users?', category: 'overview' },
+    { id: 'q_key_features', text: 'What are the key features?', category: 'overview' }
+  ],
+  deployment: [
+    { id: 'q_deployment_strategy', text: 'What deployment strategy will you use?', category: 'deployment' },
+    { id: 'q_hosting_provider', text: 'Which hosting provider?', category: 'deployment' },
+    { id: 'q_cicd_pipeline', text: 'What CI/CD pipeline?', category: 'deployment' }
+  ],
+  testing: [
+    { id: 'q_testing_framework', text: 'What testing framework?', category: 'testing' },
+    { id: 'q_test_coverage', text: 'What is your target test coverage?', category: 'testing' },
+    { id: 'q_e2e_testing', text: 'Will you implement E2E testing?', category: 'testing' }
+  ],
+  security: [
+    { id: 'q_auth_method', text: 'What authentication method?', category: 'security' },
+    { id: 'q_data_encryption', text: 'How will data be encrypted?', category: 'security' },
+    { id: 'q_security_audit', text: 'Will you conduct security audits?', category: 'security' }
+  ],
+  database: [
+    { id: 'q_database_type', text: 'What type of database?', category: 'database' },
+    { id: 'q_orm_choice', text: 'Which ORM will you use?', category: 'database' },
+    { id: 'q_data_backup', text: 'What is your backup strategy?', category: 'database' }
+  ]
+};
+
+// Flatten questions for easy access
+const ALL_QUESTIONS = Object.values(QUESTIONS).flat();
+
+/**
+ * Generate UUID
+ */
+function uuid() {
+  return crypto.randomUUID();
+}
+
+/**
+ * Generate timestamp for days ago
+ */
+function daysAgo(days) {
+  const date = new Date();
+  date.setDate(date.getDate() - days);
+  return date.toISOString();
+}
+
+/**
+ * Random element from array
+ */
+function randomFrom(array) {
+  return array[Math.floor(Math.random() * array.length)];
+}
+
+/**
+ * Generate a session with skips and answers
+ */
+function generateSession(daysBack, skipRate = 0.3, skipCategories = []) {
+  const sessionId = uuid();
+  const timestamp = daysAgo(daysBack);
+  const skips = [];
+  const answers = [];
+
+  // Process each question
+  for (const question of ALL_QUESTIONS) {
+    const shouldSkip = skipCategories.includes(question.category) || Math.random() < skipRate;
+
+    if (shouldSkip) {
+      skips.push({
+        questionId: question.id,
+        text: question.text,
+        category: question.category,
+        phase: 'discovery',
+        action: 'skipped',
+        reason: skipCategories.includes(question.category) ? 'filtered' : 'manual',
+        timeViewed: Math.random() * 5 + 1,
+        relevanceScore: Math.floor(Math.random() * 50) + 20,
+        skipReason: 'Not relevant for this project'
+      });
+    } else {
+      answers.push({
+        questionId: question.id,
+        text: question.text,
+        category: question.category,
+        phase: 'discovery',
+        action: 'answered',
+        answerLength: Math.floor(Math.random() * 300) + 50,
+        wordCount: Math.floor(Math.random() * 50) + 10,
+        timeSpent: Math.random() * 60 + 15,
+        qualityScore: Math.floor(Math.random() * 30) + 70,
+        richness: Math.random() * 0.3 + 0.6,
+        relevanceScore: Math.floor(Math.random() * 20) + 80
+      });
+    }
+  }
+
+  return {
+    skipSession: {
+      sessionId,
+      timestamp,
+      projectType: 'web-app',
+      frameworks: ['react', 'express'],
+      languages: ['javascript', 'typescript'],
+      skips,
+      answers: []
+    },
+    answerSession: {
+      sessionId,
+      timestamp,
+      projectType: 'web-app',
+      frameworks: ['react', 'express'],
+      answers
+    }
+  };
+}
+
+/**
+ * Generate patterns from session data
+ */
+function generatePatterns(skipHistory, confidence = 90) {
+  const patterns = [];
+  const questionSkipCounts = {};
+
+  // Count skips per question
+  for (const session of skipHistory.sessions) {
+    for (const skip of session.skips) {
+      if (!questionSkipCounts[skip.questionId]) {
+        questionSkipCounts[skip.questionId] = {
+          count: 0,
+          question: skip
+        };
+      }
+      questionSkipCounts[skip.questionId].count++;
+    }
+  }
+
+  // Create patterns for frequently skipped questions
+  const totalSessions = skipHistory.sessions.length;
+  for (const [questionId, data] of Object.entries(questionSkipCounts)) {
+    if (data.count >= 3) { // Minimum 3 occurrences for pattern
+      const patternConfidence = Math.min(100, Math.round((data.count / totalSessions) * 100));
+      const daysOld = Math.floor(Math.random() * 60) + 10; // 10-70 days old
+
+      patterns.push({
+        id: `pattern_skip_${questionId}`,
+        type: 'consistent_skip',
+        questionId,
+        questionText: data.question.text,
+        category: data.question.category,
+        confidence: patternConfidence,
+        sessionsAnalyzed: totalSessions,
+        skipCount: data.count,
+        recommendation: 'Auto-filter this question',
+        status: 'active',
+        userApproved: patternConfidence >= 85,
+        createdAt: daysAgo(daysOld),
+        lastSeen: daysAgo(Math.floor(Math.random() * 10)),
+        timesApplied: data.count,
+        timesRenewed: Math.floor(data.count / 3),
+        lastDecayCalculation: daysAgo(1)
+      });
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Generate learned rules from patterns
+ */
+function generateRules(patterns) {
+  return patterns
+    .filter(p => p.userApproved)
+    .map(pattern => ({
+      id: `rule_${pattern.id}`,
+      patternId: pattern.id,
+      type: 'question_filter',
+      enabled: true,
+      createdAt: pattern.createdAt,
+      appliedCount: pattern.timesApplied,
+      lastApplied: pattern.lastSeen
+    }));
+}
+
+/**
+ * Calculate stats
+ */
+function calculateStats(skipHistory, answerHistory, patterns, rules) {
+  const totalSessions = skipHistory.sessions.length;
+  const totalSkips = skipHistory.sessions.reduce((sum, s) => sum + s.skips.length, 0);
+  const totalAnswers = answerHistory.sessions.reduce((sum, s) => sum + s.answers.length, 0);
+
+  return {
+    version: '1.0',
+    totalSessions,
+    totalSkips,
+    totalAnswers,
+    patternsDetected: patterns.length,
+    rulesApplied: rules.filter(r => r.enabled).length,
+    lastUpdated: new Date().toISOString()
+  };
+}
+
+/**
+ * Generate default config
+ */
+function generateConfig() {
+  return {
+    version: '1.0',
+    enabled: true,
+    trackSkips: true,
+    trackAnswers: true,
+    minSessionsForPattern: 3,
+    minConfidenceForAutoFilter: 75,
+    maxPatternsToStore: 100,
+    autoApproveHighConfidence: false,
+    decayConfig: {
+      enabled: true,
+      decayRates: {
+        high: 0.075,
+        medium: 0.15,
+        low: 0.225
+      },
+      removalThresholds: {
+        minConfidence: 40,
+        maxInactiveMonths: 6
+      },
+      renewalBonus: 10,
+      protectionMultiplier: 0.5
+    },
+    lastUpdated: new Date().toISOString()
+  };
+}
+
+// ============================================================================
+// SCENARIO GENERATORS
+// ============================================================================
+
+/**
+ * Scenario 1: Empty State
+ */
+function generateEmptyScenario() {
+  console.log('📭 Generating Empty State scenario...');
+
+  return {
+    skipHistory: { version: '1.0', sessions: [] },
+    answerHistory: { version: '1.0', sessions: [] },
+    patterns: { version: '1.0', lastUpdated: new Date().toISOString(), patterns: [] },
+    rules: { version: '1.0', rules: [] },
+    stats: {
+      version: '1.0',
+      totalSessions: 0,
+      totalSkips: 0,
+      totalAnswers: 0,
+      patternsDetected: 0,
+      rulesApplied: 0,
+      lastUpdated: new Date().toISOString()
+    },
+    config: generateConfig()
+  };
+}
+
+/**
+ * Scenario 2: New User (2 sessions, minimal data)
+ */
+function generateNewUserScenario() {
+  console.log('🆕 Generating New User scenario (2 sessions)...');
+
+  const skipSessions = [];
+  const answerSessions = [];
+
+  // Generate 2 sessions
+  for (let i = 0; i < 2; i++) {
+    const session = generateSession(i * 7, 0.25, []); // 25% skip rate, no filters
+    skipSessions.push(session.skipSession);
+    answerSessions.push(session.answerSession);
+  }
+
+  const skipHistory = { version: '1.0', sessions: skipSessions };
+  const answerHistory = { version: '1.0', sessions: answerSessions };
+  const patterns = { version: '1.0', lastUpdated: new Date().toISOString(), patterns: [] }; // No patterns yet
+  const rules = { version: '1.0', rules: [] };
+  const stats = calculateStats(skipHistory, answerHistory, [], []);
+  const config = generateConfig();
+
+  return { skipHistory, answerHistory, patterns, rules, stats, config };
+}
+
+/**
+ * Scenario 3: Active User (12 sessions, 5 patterns, varied skip rates)
+ */
+function generateActiveUserScenario() {
+  console.log('💼 Generating Active User scenario (12 sessions, 5+ patterns)...');
+
+  const skipSessions = [];
+  const answerSessions = [];
+
+  // Categories to consistently skip (will create patterns)
+  const skipCategories = ['deployment', 'security'];
+
+  // Generate 12 sessions over 8 weeks
+  for (let i = 0; i < 12; i++) {
+    const daysBack = i * 4; // Every 4 days
+    const skipRate = 0.3 + Math.random() * 0.2; // 30-50% skip rate
+    const session = generateSession(daysBack, skipRate, skipCategories);
+    skipSessions.push(session.skipSession);
+    answerSessions.push(session.answerSession);
+  }
+
+  const skipHistory = { version: '1.0', sessions: skipSessions };
+  const answerHistory = { version: '1.0', sessions: answerSessions };
+  const allPatterns = generatePatterns(skipHistory, 85);
+  const patterns = {
+    version: '1.0',
+    lastUpdated: new Date().toISOString(),
+    lastDecayCheck: new Date().toISOString(),
+    patterns: allPatterns
+  };
+  const allRules = generateRules(allPatterns);
+  const rules = { version: '1.0', rules: allRules };
+  const stats = calculateStats(skipHistory, answerHistory, allPatterns, allRules);
+  const config = generateConfig();
+
+  return { skipHistory, answerHistory, patterns, rules, stats, config };
+}
+
+/**
+ * Scenario 4: Power User (20 sessions, 10+ patterns, decay effects)
+ */
+function generatePowerUserScenario() {
+  console.log('🚀 Generating Power User scenario (20 sessions, 10+ patterns, decay effects)...');
+
+  const skipSessions = [];
+  const answerSessions = [];
+
+  // More categories to skip
+  const skipCategories = ['deployment', 'security', 'testing'];
+
+  // Generate 20 sessions over 12 weeks
+  for (let i = 0; i < 20; i++) {
+    const daysBack = i * 4; // Every 4 days
+    const skipRate = 0.4 + Math.random() * 0.15; // 40-55% skip rate
+    const session = generateSession(daysBack, skipRate, skipCategories);
+    skipSessions.push(session.skipSession);
+    answerSessions.push(session.answerSession);
+  }
+
+  const skipHistory = { version: '1.0', sessions: skipSessions };
+  const answerHistory = { version: '1.0', sessions: answerSessions };
+  const allPatterns = generatePatterns(skipHistory, 90);
+
+  // Add some patterns with decay effects
+  allPatterns.push({
+    id: 'pattern_old_critical',
+    type: 'consistent_skip',
+    questionId: 'q_old_question',
+    questionText: 'Old question (critical decay)',
+    category: 'testing',
+    confidence: 45,
+    sessionsAnalyzed: 20,
+    skipCount: 9,
+    recommendation: 'Auto-filter this question',
+    status: 'active',
+    userApproved: false,
+    createdAt: daysAgo(180), // 6 months old
+    lastSeen: daysAgo(120), // Last seen 4 months ago
+    timesApplied: 9,
+    timesRenewed: 0,
+    lastDecayCalculation: daysAgo(1)
+  });
+
+  const patterns = {
+    version: '1.0',
+    lastUpdated: new Date().toISOString(),
+    lastDecayCheck: new Date().toISOString(),
+    patterns: allPatterns
+  };
+  const allRules = generateRules(allPatterns);
+  const rules = { version: '1.0', rules: allRules };
+  const stats = calculateStats(skipHistory, answerHistory, allPatterns, allRules);
+  const config = generateConfig();
+
+  return { skipHistory, answerHistory, patterns, rules, stats, config };
+}
+
+/**
+ * Scenario 5: Edge Cases (100% skip rates, critical patterns, large dataset)
+ */
+function generateEdgeCasesScenario() {
+  console.log('⚠️  Generating Edge Cases scenario (extreme values, edge conditions)...');
+
+  const skipSessions = [];
+  const answerSessions = [];
+
+  // Generate 15 sessions
+  for (let i = 0; i < 15; i++) {
+    const daysBack = i * 5;
+    const skipRate = i % 3 === 0 ? 1.0 : 0.3; // Some sessions with 100% skip rate
+    const skipCategories = i < 5 ? ['deployment', 'security', 'database'] : [];
+    const session = generateSession(daysBack, skipRate, skipCategories);
+    skipSessions.push(session.skipSession);
+    answerSessions.push(session.answerSession);
+  }
+
+  const skipHistory = { version: '1.0', sessions: skipSessions };
+  const answerHistory = { version: '1.0', sessions: answerSessions };
+  const allPatterns = generatePatterns(skipHistory, 95);
+
+  // Add edge case patterns
+  allPatterns.push(
+    {
+      id: 'pattern_100pct_skip',
+      type: 'consistent_skip',
+      questionId: 'q_always_skip',
+      questionText: 'Always skipped question (100% skip rate)',
+      category: 'deployment',
+      confidence: 100,
+      sessionsAnalyzed: 15,
+      skipCount: 15,
+      recommendation: 'Auto-filter this question',
+      status: 'active',
+      userApproved: true,
+      createdAt: daysAgo(45),
+      lastSeen: daysAgo(1),
+      timesApplied: 15,
+      timesRenewed: 5,
+      lastDecayCalculation: daysAgo(1)
+    },
+    {
+      id: 'pattern_very_old',
+      type: 'consistent_skip',
+      questionId: 'q_very_old',
+      questionText: 'Very old inactive pattern',
+      category: 'security',
+      confidence: 35,
+      sessionsAnalyzed: 15,
+      skipCount: 5,
+      recommendation: 'Auto-filter this question',
+      status: 'active',
+      userApproved: false,
+      createdAt: daysAgo(365), // 1 year old
+      lastSeen: daysAgo(200), // Last seen 200 days ago
+      timesApplied: 5,
+      timesRenewed: 0,
+      lastDecayCalculation: daysAgo(1)
+    }
+  );
+
+  const patterns = {
+    version: '1.0',
+    lastUpdated: new Date().toISOString(),
+    lastDecayCheck: new Date().toISOString(),
+    patterns: allPatterns
+  };
+  const allRules = generateRules(allPatterns);
+  const rules = { version: '1.0', rules: allRules };
+  const stats = calculateStats(skipHistory, answerHistory, allPatterns, allRules);
+  const config = generateConfig();
+
+  return { skipHistory, answerHistory, patterns, rules, stats, config };
+}
+
+// ============================================================================
+// MAIN EXECUTION
+// ============================================================================
+
+async function writeData(data) {
+  await fs.ensureDir(OUTPUT_DIR);
+
+  await fs.writeJSON(path.join(OUTPUT_DIR, 'skip-history.json'), data.skipHistory, { spaces: 2 });
+  await fs.writeJSON(path.join(OUTPUT_DIR, 'answer-history.json'), data.answerHistory, { spaces: 2 });
+  await fs.writeJSON(path.join(OUTPUT_DIR, 'patterns.json'), data.patterns, { spaces: 2 });
+  await fs.writeJSON(path.join(OUTPUT_DIR, 'learned-rules.json'), data.rules, { spaces: 2 });
+  await fs.writeJSON(path.join(OUTPUT_DIR, 'stats.json'), data.stats, { spaces: 2 });
+  await fs.writeJSON(path.join(OUTPUT_DIR, 'config.json'), data.config, { spaces: 2 });
+}
+
+async function main() {
+  const scenario = process.argv[2] || 'active';
+
+  console.log('');
+  console.log('🧪 Learning Analytics Test Data Generator');
+  console.log('==========================================');
+  console.log('');
+
+  let data;
+
+  switch (scenario.toLowerCase()) {
+    case 'empty':
+      data = generateEmptyScenario();
+      break;
+    case 'new':
+      data = generateNewUserScenario();
+      break;
+    case 'active':
+      data = generateActiveUserScenario();
+      break;
+    case 'power':
+      data = generatePowerUserScenario();
+      break;
+    case 'edge':
+      data = generateEdgeCasesScenario();
+      break;
+    default:
+      console.error(`❌ Unknown scenario: ${scenario}`);
+      console.log('');
+      console.log('Available scenarios:');
+      console.log('  empty  - Empty state (no data)');
+      console.log('  new    - New user (2 sessions, no patterns)');
+      console.log('  active - Active user (12 sessions, 5+ patterns)');
+      console.log('  power  - Power user (20 sessions, 10+ patterns, decay effects)');
+      console.log('  edge   - Edge cases (100% skip rates, critical patterns)');
+      console.log('');
+      process.exit(1);
+  }
+
+  await writeData(data);
+
+  console.log('');
+  console.log(`✅ Test data generated: ${scenario}`);
+  console.log(`📁 Location: ${OUTPUT_DIR}`);
+  console.log('');
+  console.log('📊 Summary:');
+  console.log(`   Sessions: ${data.stats.totalSessions}`);
+  console.log(`   Skips: ${data.stats.totalSkips}`);
+  console.log(`   Answers: ${data.stats.totalAnswers}`);
+  console.log(`   Patterns: ${data.stats.patternsDetected}`);
+  console.log(`   Rules: ${data.stats.rulesApplied}`);
+  console.log('');
+  console.log('🚀 Ready to test! Run: adf config → Learning System → Analytics Dashboard');
+  console.log('');
+}
+
+main().catch(error => {
+  console.error('❌ Error:', error.message);
+  process.exit(1);
+});