@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/.project/docs/designs/LEARNING-ANALYTICS-DASHBOARD.md

@@ -0,0 +1,1383 @@
+# Learning Analytics Dashboard - Design Specification
+
+**Version:** 1.0
+**Date:** 2025-10-27
+**Phase:** Phase 6 - Advanced Learning Features
+**Status:** Design Complete
+
+---
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Goals](#goals)
+3. [Data Sources](#data-sources)
+4. [Analytics Metrics](#analytics-metrics)
+5. [Dashboard Interface](#dashboard-interface)
+6. [Calculations & Algorithms](#calculations--algorithms)
+7. [Export Formats](#export-formats)
+8. [Implementation Plan](#implementation-plan)
+9. [Testing Strategy](#testing-strategy)
+
+---
+
+## Overview
+
+The Learning Analytics Dashboard provides comprehensive insights into the ADF CLI learning system's behavior, effectiveness, and user patterns. It enables users to understand how the learning system is performing and make data-driven decisions about their learned preferences.
+
+**Key Features:**
+- 10+ meaningful analytics metrics
+- Time-series trend visualization (ASCII charts)
+- Pattern confidence distribution analysis
+- Learning effectiveness calculations
+- Export to JSON/CSV for external analysis
+- Performance optimized for large datasets
+
+---
+
+## Goals
+
+### Primary Goals
+1. **Transparency** - Show users what the learning system has learned
+2. **Insights** - Provide actionable insights about skip behavior and patterns
+3. **Effectiveness** - Measure time savings and filtering accuracy
+4. **Confidence** - Display pattern confidence distribution and decay status
+5. **Export** - Enable data export for team sharing and external tools
+
+### Success Criteria
+- Dashboard shows 10+ meaningful insights
+- Performance acceptable with 100+ sessions (< 2 seconds load time)
+- Export works in both JSON and CSV formats
+- All metrics have clear explanations
+- Visual charts render correctly in CLI
+
+---
+
+## Data Sources
+
+### 1. Skip History (`skip-history.json`)
+```json
+{
+  "version": "1.0",
+  "sessions": [
+    {
+      "sessionId": "uuid",
+      "timestamp": "2025-10-27T...",
+      "projectType": "cli-tool",
+      "frameworks": ["commander"],
+      "languages": ["javascript"],
+      "skips": [
+        {
+          "questionId": "q_deployment_strategy",
+          "text": "What deployment strategy?",
+          "category": "deployment",
+          "phase": "planning",
+          "action": "skipped",
+          "reason": "manual",  // or "filtered"
+          "timeViewed": 2.5,
+          "relevanceScore": 30,
+          "skipReason": "Not relevant for CLI"
+        }
+      ],
+      "answers": []
+    }
+  ]
+}
+```
+
+### 2. Answer History (`answer-history.json`)
+```json
+{
+  "version": "1.0",
+  "sessions": [
+    {
+      "sessionId": "uuid",
+      "timestamp": "2025-10-27T...",
+      "projectType": "cli-tool",
+      "frameworks": ["commander"],
+      "answers": [
+        {
+          "questionId": "q_core_purpose",
+          "text": "What is the core purpose?",
+          "category": "overview",
+          "phase": "discovery",
+          "action": "answered",
+          "answerLength": 250,
+          "wordCount": 45,
+          "timeSpent": 45.2,
+          "qualityScore": 85,
+          "richness": 0.72,
+          "relevanceScore": 100
+        }
+      ]
+    }
+  ]
+}
+```
+
+### 3. Patterns (`patterns.json`)
+```json
+{
+  "version": "1.0",
+  "lastUpdated": "2025-10-27T...",
+  "lastDecayCheck": "2025-10-27T...",
+  "patterns": [
+    {
+      "id": "pattern_skip_q_deployment_strategy",
+      "type": "consistent_skip",
+      "questionId": "q_deployment_strategy",
+      "questionText": "What deployment strategy?",
+      "category": "deployment",
+      "confidence": 100,
+      "sessionsAnalyzed": 5,
+      "skipCount": 5,
+      "recommendation": "Auto-filter this question",
+      "status": "active",
+      "userApproved": true,
+      "createdAt": "2025-10-15T...",
+      "lastSeen": "2025-10-27T...",
+      "timesRenewed": 2,
+      "lastDecayCalculation": "2025-10-27T..."
+    }
+  ]
+}
+```
+
+### 4. Learned Rules (`learned-rules.json`)
+```json
+{
+  "version": "1.0",
+  "rules": [
+    {
+      "id": "rule_skip_q_deployment_strategy",
+      "patternId": "pattern_skip_q_deployment_strategy",
+      "type": "question_filter",
+      "enabled": true,
+      "createdAt": "2025-10-15T...",
+      "appliedCount": 12,
+      "lastApplied": "2025-10-27T..."
+    }
+  ]
+}
+```
+
+### 5. Statistics (`stats.json`)
+```json
+{
+  "version": "1.0",
+  "totalSessions": 15,
+  "totalSkips": 45,
+  "totalAnswers": 120,
+  "patternsDetected": 8,
+  "rulesApplied": 3,
+  "lastUpdated": "2025-10-27T..."
+}
+```
+
+---
+
+## Analytics Metrics
+
+### 1. Overview Statistics
+**Purpose:** High-level summary of learning system activity
+
+**Metrics:**
+- Total sessions conducted
+- Total questions skipped (manual + filtered)
+- Total questions answered
+- Active patterns count
+- Active learned rules count
+- Learning system age (days since first session)
+- Data size (MB)
+
+**Calculation:**
+```javascript
+{
+  totalSessions: stats.totalSessions,
+  totalSkips: stats.totalSkips,
+  totalAnswers: stats.totalAnswers,
+  activePatterns: patterns.patterns.filter(p => p.status === 'active').length,
+  activeRules: rules.rules.filter(r => r.enabled).length,
+  learningAge: daysSince(firstSession.timestamp),
+  dataSize: await storage.getLearningDataSize() / 1024 / 1024  // MB
+}
+```
+
+---
+
+### 2. Skip Trends Over Time
+**Purpose:** Visualize skip behavior evolution
+
+**Metrics:**
+- Skip count by week (last 12 weeks)
+- Manual skips vs filtered skips over time
+- Skip rate trend (% of questions skipped)
+
+**Calculation:**
+```javascript
+function calculateSkipTrends(skipHistory) {
+  const weeks = getLast12Weeks();
+  const trendData = weeks.map(week => {
+    const weekSessions = filterSessionsByWeek(skipHistory.sessions, week);
+    const manualSkips = countSkipsByReason(weekSessions, 'manual');
+    const filteredSkips = countSkipsByReason(weekSessions, 'filtered');
+    const totalQuestions = manualSkips + filteredSkips + countAnswers(weekSessions);
+
+    return {
+      week: week.label,
+      manualSkips,
+      filteredSkips,
+      totalSkips: manualSkips + filteredSkips,
+      skipRate: Math.round((manualSkips + filteredSkips) / totalQuestions * 100)
+    };
+  });
+
+  return trendData;
+}
+```
+
+**Visualization:** ASCII bar chart
+```
+Skip Trends (Last 12 Weeks)
+Week 40: ████████░░ 15 skips (8 manual, 7 filtered)
+Week 41: ██████████ 20 skips (12 manual, 8 filtered)
+Week 42: ████░░░░░░ 8 skips (5 manual, 3 filtered)
+...
+```
+
+---
+
+### 3. Category Preference Heatmap
+**Purpose:** Show skip rates by question category
+
+**Metrics:**
+- Skip rate per category (%)
+- Most skipped categories (top 5)
+- Least skipped categories (bottom 5)
+- Category skip trend (increasing/decreasing)
+
+**Calculation:**
+```javascript
+function calculateCategoryPreferences(skipHistory, answerHistory) {
+  const categories = {};
+
+  // Count skips and answers by category
+  for (const session of skipHistory.sessions) {
+    for (const skip of session.skips) {
+      if (!skip.category) continue;
+      if (!categories[skip.category]) {
+        categories[skip.category] = { skips: 0, answers: 0 };
+      }
+      categories[skip.category].skips++;
+    }
+  }
+
+  for (const session of answerHistory.sessions) {
+    for (const answer of session.answers) {
+      if (!answer.category) continue;
+      if (!categories[answer.category]) {
+        categories[answer.category] = { skips: 0, answers: 0 };
+      }
+      categories[answer.category].answers++;
+    }
+  }
+
+  // Calculate skip rates
+  return Object.entries(categories).map(([category, data]) => {
+    const total = data.skips + data.answers;
+    const skipRate = Math.round((data.skips / total) * 100);
+
+    return {
+      category,
+      skips: data.skips,
+      answers: data.answers,
+      total,
+      skipRate,
+      level: getSkipLevel(skipRate)  // "low", "medium", "high"
+    };
+  }).sort((a, b) => b.skipRate - a.skipRate);
+}
+
+function getSkipLevel(skipRate) {
+  if (skipRate >= 70) return 'high';
+  if (skipRate >= 40) return 'medium';
+  return 'low';
+}
+```
+
+**Visualization:** ASCII heatmap
+```
+Category Preferences (Skip Rate)
+deployment       ████████████████████ 95% (19/20)  HIGH
+UI/UX            ██████████████░░░░░░ 70% (14/20)  HIGH
+documentation    ████████░░░░░░░░░░░░ 40% (8/20)   MEDIUM
+architecture     ███░░░░░░░░░░░░░░░░░ 15% (3/20)   LOW
+core-features    ██░░░░░░░░░░░░░░░░░░ 10% (2/20)   LOW
+```
+
+---
+
+### 4. Pattern Confidence Distribution
+**Purpose:** Show distribution of pattern confidence scores
+
+**Metrics:**
+- Patterns by confidence level (high/medium/low)
+- Average pattern confidence
+- Pattern confidence trend (improving/declining)
+- Patterns approaching removal threshold
+
+**Calculation:**
+```javascript
+function calculatePatternDistribution(patterns) {
+  const distribution = {
+    high: patterns.filter(p => p.confidence >= 90).length,      // 90%+
+    medium: patterns.filter(p => p.confidence >= 75 && p.confidence < 90).length,  // 75-89%
+    low: patterns.filter(p => p.confidence < 75 && p.confidence >= 50).length,     // 50-74%
+    veryLow: patterns.filter(p => p.confidence < 50).length    // <50%
+  };
+
+  const avgConfidence = patterns.reduce((sum, p) => sum + p.confidence, 0) / patterns.length;
+
+  const atRisk = patterns.filter(p => p.confidence < 50 || isInactive(p, 5));  // <50 or 5+ months inactive
+
+  return {
+    distribution,
+    avgConfidence: Math.round(avgConfidence),
+    totalPatterns: patterns.length,
+    atRiskCount: atRisk.length,
+    atRiskPatterns: atRisk
+  };
+}
+```
+
+**Visualization:** ASCII pie chart representation
+```
+Pattern Confidence Distribution
+High (90%+):    ████████░░ 8 patterns (53%)
+Medium (75-89%): ████░░░░░░ 4 patterns (27%)
+Low (50-74%):   ██░░░░░░░░ 2 patterns (13%)
+Very Low (<50%): █░░░░░░░░░ 1 pattern  (7%)
+
+Average Confidence: 78%
+At Risk (decay): 1 pattern
+```
+
+---
+
+### 5. Learning Effectiveness
+**Purpose:** Measure learning system's impact and accuracy
+
+**Metrics:**
+- Time saved (estimated minutes)
+- Questions auto-filtered successfully
+- False positive rate (filtered but should answer)
+- Pattern accuracy (approved patterns / total patterns)
+- Rule application rate (how often rules are triggered)
+
+**Calculation:**
+```javascript
+function calculateEffectiveness(skipHistory, patterns, rules) {
+  // Time saved: filtered questions × avg time per question
+  const avgTimePerQuestion = 2.5;  // minutes (from answer data)
+  const questionsFiltered = countFilteredQuestions(skipHistory);
+  const timeSavedMinutes = Math.round(questionsFiltered * avgTimePerQuestion);
+
+  // False positives: filtered questions that user later answered manually
+  // (This would require tracking if a filtered question was later answered)
+  const falsePositives = 0;  // TODO: Implement tracking in Phase 6.1
+
+  // Pattern accuracy: user-approved patterns / total patterns
+  const approvedPatterns = patterns.filter(p => p.userApproved).length;
+  const patternAccuracy = Math.round((approvedPatterns / patterns.length) * 100);
+
+  // Rule application rate: how often rules actually filter questions
+  const totalRuleApplications = rules.reduce((sum, r) => sum + (r.appliedCount || 0), 0);
+  const avgApplicationsPerRule = Math.round(totalRuleApplications / rules.length);
+
+  return {
+    timeSavedMinutes,
+    questionsFiltered,
+    falsePositives,
+    falsePositiveRate: 0,  // TODO
+    patternAccuracy,
+    totalRuleApplications,
+    avgApplicationsPerRule,
+    effectiveness: calculateOverallEffectiveness(patternAccuracy, falsePositives)
+  };
+}
+
+function calculateOverallEffectiveness(accuracy, falsePositives) {
+  // Simple formula: accuracy - (falsePositives * 5)
+  // Each false positive reduces effectiveness by 5%
+  const effectiveness = accuracy - (falsePositives * 5);
+  return Math.max(0, Math.min(100, effectiveness));
+}
+```
+
+**Visualization:**
+```
+Learning Effectiveness
+
+Time Saved:        145 minutes (2.4 hours)
+Questions Filtered: 58 questions
+Pattern Accuracy:   87% (13/15 patterns approved)
+Rule Applications:  42 total (3.5 avg per rule)
+
+Overall Effectiveness: 87%
+Status: EXCELLENT ✓
+```
+
+---
+
+### 6. Pattern Decay Status
+**Purpose:** Show pattern health and decay trends
+
+**Metrics:**
+- Patterns by decay status (healthy/warning/critical)
+- Patterns renewed in last 30 days
+- Patterns approaching removal threshold
+- Average pattern age (days)
+- Decay rate distribution
+
+**Calculation:**
+```javascript
+function calculateDecayStatus(patterns, decayConfig) {
+  const now = new Date();
+  const decayStatus = {
+    healthy: [],
+    warning: [],
+    critical: []
+  };
+
+  for (const pattern of patterns) {
+    const daysSinceLastSeen = daysBetween(new Date(pattern.lastSeen), now);
+    const monthsInactive = daysSinceLastSeen / 30;
+
+    // Categorize by confidence and inactivity
+    if (pattern.confidence >= 75 && monthsInactive < 3) {
+      decayStatus.healthy.push(pattern);
+    } else if (pattern.confidence >= 50 && monthsInactive < 5) {
+      decayStatus.warning.push(pattern);
+    } else {
+      decayStatus.critical.push(pattern);
+    }
+  }
+
+  const recentlyRenewed = patterns.filter(p => {
+    const renewalDate = new Date(pattern.lastSeen);
+    return daysBetween(renewalDate, now) <= 30;
+  });
+
+  const avgAge = patterns.reduce((sum, p) => {
+    return sum + daysBetween(new Date(p.createdAt), now);
+  }, 0) / patterns.length;
+
+  return {
+    healthy: decayStatus.healthy.length,
+    warning: decayStatus.warning.length,
+    critical: decayStatus.critical.length,
+    recentlyRenewed: recentlyRenewed.length,
+    avgAge: Math.round(avgAge),
+    needsAttention: decayStatus.critical
+  };
+}
+```
+
+**Visualization:**
+```
+Pattern Decay Status
+
+Healthy (75%+, <3mo):   ████████░░ 8 patterns (53%)
+Warning (50-74%, 3-5mo): ████░░░░░░ 4 patterns (27%)
+Critical (<50%, >5mo):   ██░░░░░░░░ 2 patterns (13%)
+Recently Renewed:       1 pattern (last 30 days)
+
+Average Pattern Age: 45 days
+Patterns Needing Attention: 2 patterns
+
+⚠ Warning: 2 patterns approaching removal threshold
+```
+
+---
+
+### 7. Session Timeline
+**Purpose:** Show session history and frequency
+
+**Metrics:**
+- Session frequency (sessions per week)
+- Session count by project type
+- Most active time period
+- Sessions with most skips/answers
+
+**Calculation:**
+```javascript
+function calculateSessionTimeline(skipHistory, answerHistory) {
+  const sessions = skipHistory.sessions;
+  const timeline = [];
+
+  for (const session of sessions) {
+    const skipCount = session.skips.length;
+    const matchingAnswerSession = answerHistory.sessions.find(
+      s => s.sessionId === session.sessionId
+    );
+    const answerCount = matchingAnswerSession ? matchingAnswerSession.answers.length : 0;
+
+    timeline.push({
+      sessionId: session.sessionId,
+      timestamp: session.timestamp,
+      projectType: session.projectType,
+      frameworks: session.frameworks,
+      skipCount,
+      answerCount,
+      totalQuestions: skipCount + answerCount
+    });
+  }
+
+  // Calculate frequency
+  const firstSession = new Date(sessions[0].timestamp);
+  const lastSession = new Date(sessions[sessions.length - 1].timestamp);
+  const weeksBetween = Math.ceil(daysBetween(firstSession, lastSession) / 7);
+  const sessionsPerWeek = sessions.length / weeksBetween;
+
+  return {
+    timeline: timeline.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp)),
+    sessionsPerWeek: sessionsPerWeek.toFixed(1),
+    totalSessions: sessions.length,
+    firstSession: firstSession.toISOString().split('T')[0],
+    lastSession: lastSession.toISOString().split('T')[0]
+  };
+}
+```
+
+---
+
+### 8. Most Impactful Patterns
+**Purpose:** Highlight patterns with biggest impact
+
+**Metrics:**
+- Top 5 patterns by time saved
+- Top 5 patterns by application count
+- Newest high-confidence patterns
+- Most consistent patterns (100% confidence)
+
+**Calculation:**
+```javascript
+function calculateImpactfulPatterns(patterns, rules, skipHistory) {
+  const impactData = [];
+
+  for (const pattern of patterns) {
+    const matchingRule = rules.find(r => r.patternId === pattern.id);
+    const appliedCount = matchingRule ? matchingRule.appliedCount : 0;
+    const timeSaved = appliedCount * 2.5;  // 2.5 min per question
+
+    impactData.push({
+      pattern,
+      appliedCount,
+      timeSaved,
+      impact: calculateImpact(appliedCount, pattern.confidence)
+    });
+  }
+
+  return {
+    topByTimeSaved: impactData.sort((a, b) => b.timeSaved - a.timeSaved).slice(0, 5),
+    topByApplications: impactData.sort((a, b) => b.appliedCount - a.appliedCount).slice(0, 5),
+    perfectConfidence: patterns.filter(p => p.confidence === 100),
+    newestHighConfidence: patterns
+      .filter(p => p.confidence >= 90)
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, 5)
+  };
+}
+
+function calculateImpact(applications, confidence) {
+  // Impact = applications × confidence × 0.01
+  return Math.round(applications * confidence * 0.01);
+}
+```
+
+---
+
+### 9. Question Statistics
+**Purpose:** Detailed question-level analytics
+
+**Metrics:**
+- Most answered questions (top 10)
+- Most skipped questions (top 10)
+- Questions with lowest skip rate
+- Average time per question by category
+
+**Calculation:**
+```javascript
+function calculateQuestionStats(skipHistory, answerHistory) {
+  const questionData = {};
+
+  // Aggregate skip data
+  for (const session of skipHistory.sessions) {
+    for (const skip of session.skips) {
+      if (!questionData[skip.questionId]) {
+        questionData[skip.questionId] = {
+          questionId: skip.questionId,
+          text: skip.text,
+          category: skip.category,
+          skips: 0,
+          answers: 0,
+          totalTimeSpent: 0,
+          avgTimeSpent: 0
+        };
+      }
+      questionData[skip.questionId].skips++;
+    }
+  }
+
+  // Aggregate answer data
+  for (const session of answerHistory.sessions) {
+    for (const answer of session.answers) {
+      if (!questionData[answer.questionId]) {
+        questionData[answer.questionId] = {
+          questionId: answer.questionId,
+          text: answer.text,
+          category: answer.category,
+          skips: 0,
+          answers: 0,
+          totalTimeSpent: 0,
+          avgTimeSpent: 0
+        };
+      }
+      questionData[answer.questionId].answers++;
+      questionData[answer.questionId].totalTimeSpent += answer.timeSpent || 0;
+    }
+  }
+
+  // Calculate averages and rates
+  const stats = Object.values(questionData).map(q => {
+    const total = q.skips + q.answers;
+    q.skipRate = Math.round((q.skips / total) * 100);
+    q.avgTimeSpent = q.answers > 0 ? Math.round(q.totalTimeSpent / q.answers) : 0;
+    return q;
+  });
+
+  return {
+    mostAnswered: stats.sort((a, b) => b.answers - a.answers).slice(0, 10),
+    mostSkipped: stats.sort((a, b) => b.skips - a.skips).slice(0, 10),
+    lowestSkipRate: stats.sort((a, b) => a.skipRate - b.skipRate).slice(0, 10),
+    avgTimeByCategory: calculateAvgTimeByCategory(stats)
+  };
+}
+```
+
+---
+
+### 10. Export Summary
+**Purpose:** Provide metadata for exported analytics
+
+**Metrics:**
+- Export timestamp
+- Data range (first session to last session)
+- Export version
+- Data completeness indicators
+
+---
+
+## Dashboard Interface
+
+### CLI Navigation Structure
+
+```
+Learning System
+├── View Skip History
+├── Review Patterns
+├── Manage Rules
+├── Analytics Dashboard  ← NEW
+│   ├── Overview
+│   ├── Skip Trends
+│   ├── Category Preferences
+│   ├── Pattern Health
+│   ├── Effectiveness
+│   ├── Question Stats
+│   └── Export Analytics
+├── Settings
+└── Clear Data
+```
+
+### Dashboard Layout
+
+```
+═══════════════════════════════════════════════════════════════
+                 LEARNING ANALYTICS DASHBOARD
+═══════════════════════════════════════════════════════════════
+
+📊 OVERVIEW
+
+Total Sessions:       15 sessions
+Total Skips:          45 questions (30 manual, 15 filtered)
+Total Answers:        120 questions
+Active Patterns:      8 patterns
+Active Rules:         3 rules
+Learning System Age:  32 days
+Data Size:            0.15 MB
+
+───────────────────────────────────────────────────────────────
+
+📈 SKIP TRENDS (Last 12 Weeks)
+
+Week 40: ████████░░ 15 skips (10 manual, 5 filtered)
+Week 41: ██████████ 20 skips (13 manual, 7 filtered)
+Week 42: ████░░░░░░ 8 skips (5 manual, 3 filtered)
+Week 43: ░░░░░░░░░░ 0 skips (no sessions)
+
+Trend: Decreasing (↓ 40% from peak)
+
+───────────────────────────────────────────────────────────────
+
+🎯 CATEGORY PREFERENCES
+
+deployment       ████████████████████ 95% (19/20)  HIGH
+UI/UX            ██████████████░░░░░░ 70% (14/20)  HIGH
+documentation    ████████░░░░░░░░░░░░ 40% (8/20)   MEDIUM
+architecture     ███░░░░░░░░░░░░░░░░░ 15% (3/20)   LOW
+core-features    ██░░░░░░░░░░░░░░░░░░ 10% (2/20)   LOW
+
+───────────────────────────────────────────────────────────────
+
+🧬 PATTERN HEALTH
+
+Healthy (75%+):   ████████░░ 8 patterns (53%)
+Warning (50-74%):  ████░░░░░░ 4 patterns (27%)
+Critical (<50%):   ██░░░░░░░░ 2 patterns (13%)
+
+Average Confidence: 78%
+Recently Renewed:   1 pattern (last 30 days)
+
+⚠ Warning: 2 patterns approaching removal threshold
+
+───────────────────────────────────────────────────────────────
+
+✨ EFFECTIVENESS
+
+Time Saved:        145 minutes (2.4 hours)
+Questions Filtered: 58 questions
+Pattern Accuracy:   87% (13/15 patterns approved)
+Rule Applications:  42 total (3.5 avg per rule)
+
+Overall Effectiveness: 87% ✓ EXCELLENT
+
+───────────────────────────────────────────────────────────────
+
+? What would you like to do?
+
+  View Detailed Skip Trends
+  View Category Breakdown
+  View Pattern Details
+  View Question Statistics
+❯ Export Analytics (JSON/CSV)
+  Back to Learning System
+
+───────────────────────────────────────────────────────────────
+```
+
+### Interactive Features
+
+1. **Navigation**
+   - Arrow keys to navigate sections
+   - Enter to select/drill down
+   - 'q' or ESC to go back
+   - 'e' to export from any view
+
+2. **Drill-Down Views**
+   - Click on any metric to see detailed breakdown
+   - Example: Click "Category Preferences" → See detailed category analysis with all questions
+
+3. **Filtering**
+   - Filter by date range
+   - Filter by project type
+   - Filter by confidence level
+
+4. **Refresh**
+   - Auto-refresh option (every N seconds)
+   - Manual refresh with 'r' key
+
+---
+
+## Calculations & Algorithms
+
+### Helper Functions
+
+```javascript
+// Date utilities
+function daysBetween(date1, date2) {
+  return Math.floor((date2 - date1) / (1000 * 60 * 60 * 24));
+}
+
+function getLast12Weeks() {
+  const weeks = [];
+  const now = new Date();
+
+  for (let i = 11; i >= 0; i--) {
+    const weekStart = new Date(now);
+    weekStart.setDate(now.getDate() - (i * 7));
+    const weekEnd = new Date(weekStart);
+    weekEnd.setDate(weekStart.getDate() + 6);
+
+    weeks.push({
+      label: `Week ${getWeekNumber(weekStart)}`,
+      start: weekStart,
+      end: weekEnd
+    });
+  }
+
+  return weeks;
+}
+
+function getWeekNumber(date) {
+  const firstDayOfYear = new Date(date.getFullYear(), 0, 1);
+  const pastDaysOfYear = (date - firstDayOfYear) / 86400000;
+  return Math.ceil((pastDaysOfYear + firstDayOfYear.getDay() + 1) / 7);
+}
+
+// Session filtering
+function filterSessionsByWeek(sessions, week) {
+  return sessions.filter(session => {
+    const sessionDate = new Date(session.timestamp);
+    return sessionDate >= week.start && sessionDate <= week.end;
+  });
+}
+
+function countSkipsByReason(sessions, reason) {
+  return sessions.reduce((count, session) => {
+    return count + session.skips.filter(s => s.reason === reason).length;
+  }, 0);
+}
+
+function countAnswers(sessions) {
+  return sessions.reduce((count, session) => {
+    return count + session.answers.length;
+  }, 0);
+}
+
+// Inactivity detection
+function isInactive(pattern, months) {
+  const now = new Date();
+  const lastSeen = new Date(pattern.lastSeen);
+  const monthsInactive = (now - lastSeen) / (1000 * 60 * 60 * 24 * 30);
+  return monthsInactive >= months;
+}
+
+// ASCII chart generation
+function generateBarChart(data, maxWidth = 20) {
+  const maxValue = Math.max(...data.map(d => d.value));
+
+  return data.map(item => {
+    const barWidth = Math.round((item.value / maxValue) * maxWidth);
+    const bar = '█'.repeat(barWidth) + '░'.repeat(maxWidth - barWidth);
+    return `${item.label.padEnd(15)} ${bar} ${item.value}`;
+  }).join('\n');
+}
+
+function generatePieChart(data, totalWidth = 10) {
+  const total = data.reduce((sum, d) => sum + d.value, 0);
+
+  return data.map(item => {
+    const percentage = Math.round((item.value / total) * 100);
+    const barWidth = Math.round((item.value / total) * totalWidth);
+    const bar = '█'.repeat(barWidth) + '░'.repeat(totalWidth - barWidth);
+    return `${item.label.padEnd(15)} ${bar} ${item.value} (${percentage}%)`;
+  }).join('\n');
+}
+```
+
+---
+
+## Export Formats
+
+### JSON Export Format
+
+```json
+{
+  "version": "1.0",
+  "exportedAt": "2025-10-27T12:34:56Z",
+  "exportType": "learning-analytics",
+  "dataRange": {
+    "firstSession": "2025-09-15T...",
+    "lastSession": "2025-10-27T...",
+    "totalSessions": 15,
+    "daysSpanned": 42
+  },
+  "overview": {
+    "totalSessions": 15,
+    "totalSkips": 45,
+    "totalAnswers": 120,
+    "activePatterns": 8,
+    "activeRules": 3,
+    "learningAge": 42,
+    "dataSizeMB": 0.15
+  },
+  "skipTrends": [
+    {
+      "week": "Week 40",
+      "manualSkips": 10,
+      "filteredSkips": 5,
+      "totalSkips": 15,
+      "skipRate": 30
+    }
+  ],
+  "categoryPreferences": [
+    {
+      "category": "deployment",
+      "skips": 19,
+      "answers": 1,
+      "total": 20,
+      "skipRate": 95,
+      "level": "high"
+    }
+  ],
+  "patternDistribution": {
+    "distribution": {
+      "high": 8,
+      "medium": 4,
+      "low": 2,
+      "veryLow": 1
+    },
+    "avgConfidence": 78,
+    "totalPatterns": 15,
+    "atRiskCount": 2
+  },
+  "effectiveness": {
+    "timeSavedMinutes": 145,
+    "questionsFiltered": 58,
+    "patternAccuracy": 87,
+    "totalRuleApplications": 42,
+    "avgApplicationsPerRule": 3.5,
+    "overallEffectiveness": 87
+  },
+  "decayStatus": {
+    "healthy": 8,
+    "warning": 4,
+    "critical": 2,
+    "recentlyRenewed": 1,
+    "avgAge": 45
+  },
+  "questionStats": {
+    "mostAnswered": [...],
+    "mostSkipped": [...],
+    "lowestSkipRate": [...]
+  }
+}
+```
+
+### CSV Export Format
+
+**File 1: `analytics-overview.csv`**
+```csv
+Metric,Value,Unit
+Total Sessions,15,sessions
+Total Skips,45,questions
+Total Answers,120,questions
+Active Patterns,8,patterns
+Active Rules,3,rules
+Learning Age,42,days
+Data Size,0.15,MB
+Time Saved,145,minutes
+Pattern Accuracy,87,%
+Overall Effectiveness,87,%
+```
+
+**File 2: `analytics-skip-trends.csv`**
+```csv
+Week,Manual Skips,Filtered Skips,Total Skips,Skip Rate
+Week 40,10,5,15,30
+Week 41,13,7,20,35
+Week 42,5,3,8,20
+```
+
+**File 3: `analytics-category-preferences.csv`**
+```csv
+Category,Skips,Answers,Total,Skip Rate,Level
+deployment,19,1,20,95,high
+UI/UX,14,6,20,70,high
+documentation,8,12,20,40,medium
+```
+
+**File 4: `analytics-patterns.csv`**
+```csv
+Pattern ID,Type,Confidence,Status,Created At,Last Seen,Times Renewed
+pattern_skip_q_deployment,consistent_skip,100,active,2025-10-15,2025-10-27,2
+```
+
+---
+
+## Implementation Plan
+
+### Phase 1: Core Analytics Module
+**Files to create:**
+- `lib/learning/analytics.js` - Core analytics module with all calculation functions
+
+**Features:**
+1. Overview statistics calculation
+2. Skip trends calculation
+3. Category preferences calculation
+4. Pattern distribution calculation
+5. Effectiveness calculation
+6. Decay status calculation
+
+**Estimated effort:** 4-6 hours
+
+---
+
+### Phase 2: Dashboard UI
+**Files to create:**
+- `lib/learning/analytics-view.js` - CLI dashboard UI
+
+**Features:**
+1. Main dashboard view with all metrics
+2. ASCII chart rendering
+3. Interactive navigation
+4. Drill-down views
+5. Color-coded output
+
+**Estimated effort:** 3-4 hours
+
+---
+
+### Phase 3: Export Functionality
+**Files to create:**
+- `lib/learning/analytics-exporter.js` - Export to JSON/CSV
+
+**Features:**
+1. JSON export with complete analytics data
+2. CSV export with multiple files
+3. Export configuration options
+4. Export validation
+
+**Estimated effort:** 2-3 hours
+
+---
+
+### Phase 4: Integration
+**Files to modify:**
+- `lib/commands/config.js` - Add "Analytics Dashboard" to learning menu
+- `lib/learning/learning-manager.js` - Integrate analytics module
+
+**Features:**
+1. Add "Analytics Dashboard" option to learning menu
+2. Integrate analytics module into learning manager
+3. Add export shortcuts
+
+**Estimated effort:** 1-2 hours
+
+---
+
+### Phase 5: Testing
+**Files to create:**
+- `tests/analytics.test.js` - Analytics calculations tests
+- `tests/analytics-view.test.js` - Dashboard UI tests (snapshot tests)
+- `tests/analytics-exporter.test.js` - Export functionality tests
+
+**Test Coverage:**
+- All metrics calculation functions
+- Edge cases (no data, single session, large datasets)
+- Export format validation
+- Performance tests (100+ sessions)
+
+**Estimated effort:** 3-4 hours
+
+---
+
+**Total Estimated Effort:** 13-19 hours (2-3 days)
+
+---
+
+## Testing Strategy
+
+### Unit Tests
+
+```javascript
+// tests/analytics.test.js
+
+describe('Analytics Calculations', () => {
+  describe('calculateOverviewStats', () => {
+    it('should calculate correct overview statistics', () => {
+      const stats = { totalSessions: 15, totalSkips: 45, totalAnswers: 120 };
+      const patterns = { patterns: [{}, {}, {}] };
+      const rules = { rules: [{}, {}] };
+
+      const result = calculateOverviewStats(stats, patterns, rules);
+
+      expect(result.totalSessions).toBe(15);
+      expect(result.totalSkips).toBe(45);
+      expect(result.activePatterns).toBe(3);
+    });
+
+    it('should handle empty data', () => {
+      const result = calculateOverviewStats({}, { patterns: [] }, { rules: [] });
+      expect(result.totalSessions).toBe(0);
+      expect(result.activePatterns).toBe(0);
+    });
+  });
+
+  describe('calculateSkipTrends', () => {
+    it('should calculate skip trends for last 12 weeks', () => {
+      const skipHistory = createMockSkipHistory(15);
+      const trends = calculateSkipTrends(skipHistory);
+
+      expect(trends).toHaveLength(12);
+      expect(trends[0]).toHaveProperty('week');
+      expect(trends[0]).toHaveProperty('manualSkips');
+      expect(trends[0]).toHaveProperty('skipRate');
+    });
+
+    it('should handle weeks with no sessions', () => {
+      const skipHistory = { sessions: [] };
+      const trends = calculateSkipTrends(skipHistory);
+
+      expect(trends).toHaveLength(12);
+      expect(trends[0].manualSkips).toBe(0);
+    });
+  });
+
+  describe('calculateCategoryPreferences', () => {
+    it('should calculate skip rates by category', () => {
+      const skipHistory = createMockSkipHistoryWithCategories();
+      const answerHistory = createMockAnswerHistoryWithCategories();
+
+      const prefs = calculateCategoryPreferences(skipHistory, answerHistory);
+
+      expect(prefs[0]).toHaveProperty('category');
+      expect(prefs[0]).toHaveProperty('skipRate');
+      expect(prefs[0]).toHaveProperty('level');
+    });
+
+    it('should sort categories by skip rate descending', () => {
+      const prefs = calculateCategoryPreferences(mockSkipHistory, mockAnswerHistory);
+
+      for (let i = 0; i < prefs.length - 1; i++) {
+        expect(prefs[i].skipRate).toBeGreaterThanOrEqual(prefs[i + 1].skipRate);
+      }
+    });
+  });
+
+  describe('calculateEffectiveness', () => {
+    it('should calculate time saved correctly', () => {
+      const skipHistory = { sessions: [{ skips: [{ reason: 'filtered' }] }] };
+      const result = calculateEffectiveness(skipHistory, [], []);
+
+      expect(result.timeSavedMinutes).toBeGreaterThan(0);
+      expect(result.questionsFiltered).toBe(1);
+    });
+
+    it('should calculate pattern accuracy', () => {
+      const patterns = [
+        { userApproved: true },
+        { userApproved: true },
+        { userApproved: false }
+      ];
+
+      const result = calculateEffectiveness({}, patterns, []);
+      expect(result.patternAccuracy).toBe(67);  // 2/3 = 66.67%
+    });
+  });
+});
+```
+
+### Integration Tests
+
+```javascript
+// tests/analytics-integration.test.js
+
+describe('Analytics Integration', () => {
+  it('should generate complete analytics from real data', async () => {
+    const projectPath = createTestProject();
+    await populateWithMockData(projectPath, 15);
+
+    const analytics = await generateAnalytics(projectPath);
+
+    expect(analytics).toHaveProperty('overview');
+    expect(analytics).toHaveProperty('skipTrends');
+    expect(analytics).toHaveProperty('categoryPreferences');
+    expect(analytics).toHaveProperty('effectiveness');
+  });
+
+  it('should export analytics to JSON', async () => {
+    const projectPath = createTestProject();
+    const analytics = await generateAnalytics(projectPath);
+
+    const exported = await exportAnalytics(analytics, 'json');
+    const parsed = JSON.parse(exported);
+
+    expect(parsed.version).toBe('1.0');
+    expect(parsed).toHaveProperty('overview');
+  });
+
+  it('should export analytics to CSV', async () => {
+    const projectPath = createTestProject();
+    const analytics = await generateAnalytics(projectPath);
+
+    const files = await exportAnalytics(analytics, 'csv');
+
+    expect(files).toHaveProperty('overview.csv');
+    expect(files).toHaveProperty('trends.csv');
+    expect(files).toHaveProperty('categories.csv');
+  });
+});
+```
+
+### Performance Tests
+
+```javascript
+// tests/analytics-performance.test.js
+
+describe('Analytics Performance', () => {
+  it('should handle 100 sessions in < 2 seconds', async () => {
+    const projectPath = createTestProject();
+    await populateWithMockData(projectPath, 100);
+
+    const startTime = Date.now();
+    await generateAnalytics(projectPath);
+    const elapsed = Date.now() - startTime;
+
+    expect(elapsed).toBeLessThan(2000);  // < 2 seconds
+  });
+
+  it('should handle 500 patterns efficiently', () => {
+    const patterns = createMockPatterns(500);
+
+    const startTime = Date.now();
+    const distribution = calculatePatternDistribution(patterns);
+    const elapsed = Date.now() - startTime;
+
+    expect(elapsed).toBeLessThan(500);  // < 500ms
+  });
+});
+```
+
+---
+
+## Success Criteria
+
+✅ **Functional Requirements:**
+- Dashboard displays 10+ meaningful metrics
+- All calculations are accurate
+- Export works in both JSON and CSV
+- Performance < 2 seconds for 100 sessions
+- UI is clear and intuitive
+
+✅ **Code Quality:**
+- 80%+ test coverage for analytics module
+- All edge cases handled (no data, single session, etc.)
+- Code follows existing patterns in codebase
+- Comprehensive JSDoc documentation
+
+✅ **User Experience:**
+- Dashboard loads instantly
+- Navigation is intuitive
+- Charts render correctly in all terminals
+- Export files are well-formatted
+
+✅ **Integration:**
+- Seamlessly integrates into `adf config` → Learning System menu
+- No breaking changes to existing functionality
+- Compatible with all other Phase 6 features
+
+---
+
+## Future Enhancements (Post-v0.6.0)
+
+1. **Visual Enhancements**
+   - Web-based dashboard (HTML export)
+   - More chart types (line charts, scatter plots)
+   - Color themes
+
+2. **Advanced Analytics**
+   - Predictive analytics (which patterns likely to decay)
+   - Anomaly detection (unusual skip behavior)
+   - Session comparison
+   - A/B testing for learned rules
+
+3. **Team Features**
+   - Aggregate analytics across team members
+   - Team benchmarking
+   - Shared insights
+
+4. **Real-Time Analytics**
+   - Live dashboard during interview
+   - Real-time effectiveness monitoring
+   - In-session recommendations
+
+---
+
+## Appendix
+
+### A. Mock Data for Testing
+
+```javascript
+function createMockSkipHistory(sessionCount) {
+  const sessions = [];
+
+  for (let i = 0; i < sessionCount; i++) {
+    const sessionDate = new Date();
+    sessionDate.setDate(sessionDate.getDate() - (i * 2));
+
+    sessions.push({
+      sessionId: `session_${i}`,
+      timestamp: sessionDate.toISOString(),
+      projectType: i % 2 === 0 ? 'cli-tool' : 'web-app',
+      frameworks: i % 2 === 0 ? ['commander'] : ['react'],
+      skips: generateRandomSkips(3, 8),
+      answers: []
+    });
+  }
+
+  return { version: '1.0', sessions };
+}
+
+function generateRandomSkips(min, max) {
+  const count = Math.floor(Math.random() * (max - min + 1)) + min;
+  const skips = [];
+
+  const categories = ['deployment', 'UI/UX', 'documentation', 'architecture', 'core-features'];
+  const reasons = ['manual', 'filtered'];
+
+  for (let i = 0; i < count; i++) {
+    skips.push({
+      questionId: `q_${Math.floor(Math.random() * 50)}`,
+      text: `Sample question ${i}`,
+      category: categories[Math.floor(Math.random() * categories.length)],
+      phase: 'planning',
+      action: 'skipped',
+      reason: reasons[Math.floor(Math.random() * reasons.length)],
+      timeViewed: Math.random() * 5,
+      relevanceScore: Math.floor(Math.random() * 100)
+    });
+  }
+
+  return skips;
+}
+```
+
+### B. ASCII Chart Examples
+
+```
+Bar Chart Example:
+deployment       ████████████████████ 95%
+UI/UX            ██████████████░░░░░░ 70%
+documentation    ████████░░░░░░░░░░░░ 40%
+
+Pie Chart Example:
+High:    ████████░░ 8 (53%)
+Medium:  ████░░░░░░ 4 (27%)
+Low:     ██░░░░░░░░ 2 (13%)
+
+Line Chart Example (Trend):
+20 |              ╭──╮
+15 |    ╭─────────╯  ╰╮
+10 |  ╭─╯              ╰─╮
+ 5 | ╭╯                  ╰─
+ 0 └──────────────────────
+   W1  W4  W7  W10  W12
+```
+
+---
+
+**End of Design Specification**
+
+**Status:** ✅ Design Complete - Ready for Implementation
+**Next Steps:** Review design → Create implementation task → Begin coding