@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/README.md

@@ -62,7 +62,7 @@ adf init --rapid --tool cursor
 
 ### Configure ADF Settings
 
-Configure ADF settings like AI provider, learning system, and more:
+Configure ADF settings like AI provider, AI analysis settings, learning system, and more:
 
 ```bash
 adf config
@@ -70,14 +70,17 @@ adf config
 
 This command provides an interactive menu with:
 - **AI Provider Setup** - Configure Anthropic, OpenAI, Google Gemini, or OpenRouter
+- **AI Analysis Settings** - Configure performance modes and AI features
+- **IDE Deployment** - Deploy to multiple IDEs
 - **Learning System** - Manage interview learning data and preferences
 - Status indicators showing what's configured (green ✓), disabled (yellow ○), or has data
-- Future configuration options (coming soon)
 
 You can run `adf config` anytime to:
 - Configure AI for the first time
 - Switch AI providers or models
 - Update your API keys
+- Adjust AI analysis performance and features
+- Deploy to development tools
 - Review learning patterns and manage learned preferences
 
 ### Deploy to Development Tool
@@ -203,6 +206,78 @@ Select "AI Provider Setup" and you'll see:
 
 Your previous API keys remain saved in `.adf/.env` for easy switching between providers.
 
+## AI Analysis Settings
+
+ADF CLI provides three performance modes and five configurable AI features, giving you complete control over the speed vs intelligence tradeoff during interviews.
+
+### Performance Modes
+
+Configure via `adf config` → AI Analysis Settings:
+
+**Fast Mode:**
+- Zero AI delays (~0.5s per answer)
+- All AI features disabled
+- Best for: Quick workflows, prototyping, low-priority projects
+
+**Balanced Mode (Default):**
+- 2-3 seconds per answer
+- Quality Analysis, Smart Filtering, and Pattern Detection enabled
+- Question Reordering and Follow-up Questions disabled
+- Best for: Most projects - optimal balance of speed and intelligence
+
+**Comprehensive Mode:**
+- 4-6 seconds per answer
+- All AI features enabled
+- Maximum intelligence and guidance
+- Best for: Complex projects, critical systems, maximum thoroughness
+
+### Configurable AI Features
+
+Five AI features can be toggled individually:
+
+1. **AI-Powered Quality Analysis** (Medium Impact: 1-2s)
+   - Real-time answer quality scoring (0-100)
+   - Improvement suggestions for low-quality answers
+   - Helps ensure comprehensive requirements gathering
+
+2. **Intelligent Question Reordering** (High Impact: 2-3s)
+   - Dynamically reorders questions based on extracted knowledge
+   - Prioritizes fundamental questions first
+   - Adapts interview flow to your answers
+
+3. **AI-Generated Follow-Up Questions** (Medium Impact: 1-2s when triggered)
+   - Context-specific follow-ups for incomplete answers
+   - Only triggers for low-quality answers (< 70 score)
+   - Helps gather missing information intelligently
+
+4. **Pattern Detection & Learning** (Low Impact: minimal)
+   - Learns from your skip behavior over time
+   - Generates learned rules from patterns
+   - Lightweight, runs locally
+
+5. **Smart Question Filtering** (Low Impact: minimal)
+   - Analyzes project type and context
+   - Filters out irrelevant questions automatically
+   - Saves time on specialized projects (CLI tools, APIs, etc.)
+
+### Configuration
+
+Access AI Analysis Settings:
+
+```bash
+adf config
+# Select "AI Analysis Settings"
+```
+
+Settings are saved to `.adf/analysis-config.json` and apply to all future interviews.
+
+**Performance Mode Display:**
+At interview start, you'll see:
+```
+🎛️  AI Analysis Mode: Balanced
+   (Configure via: adf config → AI Analysis Settings)
+```
+
 ## Learning System
 
 ADF CLI includes an intelligent Learning System that improves your interview experience by learning from your behavior across sessions.
@@ -216,7 +291,13 @@ ADF CLI includes an intelligent Learning System that improves your interview exp
    - Framework-specific skips (e.g., routing questions for Next.js projects)
    - Answer style preferences (brief vs detailed)
 3. **Rule Generation** - Converts high-confidence patterns (≥75%) into learned rules
-4. **Adaptive Filtering** - Applies learned rules in future interviews (with your approval)
+4. **Pattern Decay** - Automatically keeps patterns fresh and relevant:
+   - Inactive patterns lose confidence over time using exponential decay
+   - High-confidence patterns (≥90%) decay slower than weak patterns
+   - Patterns reconfirmed by your behavior get +10 confidence boost
+   - Stale patterns (confidence <40 or inactive 6+ months) automatically removed
+   - User-approved patterns protected (decay at half rate)
+5. **Adaptive Filtering** - Applies learned rules in future interviews (with your approval)
 
 ### Managing Learning Data
 
@@ -414,27 +495,41 @@ When we release updates to the framework:
 
 See [CHANGELOG.md](./CHANGELOG.md) for detailed version history.
 
-**Latest:** v0.4.12
-- **Learning System (Phase 4.2)** - Learns from your skip behavior to improve filtering
-  - Automatic pattern detection across interview sessions
-  - Learned rule generation from high-confidence patterns
-  - Adaptive filtering with user approval
-  - Learning management CLI via `adf config`
-  - Privacy-first local storage in `.adf/learning/`
-- **Smart Question Filtering (Phase 4.1)** - Context-aware question filtering
-  - Project analysis (type, frameworks, languages)
-  - Intelligent question relevance scoring
-  - Time estimation for skipped questions
-  - User control with confidence thresholds
-- Enhanced config command with Learning System integration
-
-**Previous:** v0.3.6
-- AI-guided requirements gathering with multi-provider support
-- Real-time answer quality analysis and intelligent follow-ups
-- Secure API key persistence in `.adf/.env`
-- Dynamic model fetching with autocomplete selection
-- Enhanced UX with visible skip instructions
-- Automatic deployment to your preferred IDE
+**Latest:** v0.10.0 (2025-10-27)
+- **Pattern Decay Algorithm (v0.10.0)** - Phase 6: Advanced Learning Features
+  - Time-based exponential decay for inactive patterns
+  - Confidence-based decay rates (high/medium/low)
+  - Automatic pattern cleanup and renewal system
+  - 40+ comprehensive tests for decay functionality
+  - Pattern metadata tracking (timestamps, renewal counts)
+  - Removal history and analytics
+
+**Previous Release:** v0.9.1 (2025-10-05)
+- **AI Analysis Settings (v0.9.0)** - Performance modes and configurable AI features
+  - Three performance modes: Fast, Balanced, Comprehensive
+  - Five individually configurable AI features
+  - Complete control over speed vs intelligence tradeoff
+  - New configuration category in `adf config`
+  - Performance mode display at interview start
+- **Resume from Exit (v0.8.0)** - Resume interviews after exit
+  - Type `exit` or press Ctrl+C to save progress and quit
+  - Resume with `adf init` continues from last question
+  - Already-answered questions automatically skipped
+  - Graceful quit handling everywhere
+- **UX Improvements (v0.5.1-v0.7.1)** - Enhanced user experience
+  - Terminal input restoration (v0.7.1)
+  - Better existing project detection with clear options
+  - Post-install information display
+  - Configuration validation and auto-reset
+
+**Previous Releases:**
+- **v0.5.0** - Intelligent Answer Analysis & Dynamic Question Pipeline
+- **v0.4.36** - Multi-IDE Improvements & Config Command Enhancement
+- **v0.4.12** - Learning System (Phase 4.2) & Smart Question Filtering (Phase 4.1)
+- **v0.3.6** - Configuration Command & Optional AI Setup
+- **v0.3.4** - Multi-Provider AI Integration (Anthropic, OpenAI, Google, OpenRouter)
+- **v0.2.0** - Quality-Based Progress Tracking & Resume Capability
+- **v0.1.0** - Initial Release
 
 ## Troubleshooting
 

package/lib/learning/analytics-exporter.js

@@ -0,0 +1,241 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Learning Analytics Exporter
+ *
+ * Handles exporting analytics data in multiple formats:
+ * - JSON: Single comprehensive file with all analytics
+ * - CSV: Multiple files for different metrics
+ */
+
+/**
+ * Export analytics data
+ * @param {Object} analyticsData - Complete analytics data
+ * @param {string} projectPath - Project root path
+ * @param {string} format - Export format ('json' or 'csv')
+ * @returns {Promise<Object>} Export result with file paths
+ */
+async function exportAnalytics(analyticsData, projectPath, format = 'json') {
+  const learningPath = path.join(projectPath, '.adf', 'learning');
+  const exportsPath = path.join(learningPath, 'exports');
+
+  // Ensure exports directory exists
+  await fs.ensureDir(exportsPath);
+
+  if (format === 'json') {
+    return await exportJSON(analyticsData, exportsPath);
+  } else if (format === 'csv') {
+    return await exportCSV(analyticsData, exportsPath);
+  } else {
+    throw new Error(`Unsupported export format: ${format}`);
+  }
+}
+
+/**
+ * Export analytics as JSON
+ * @param {Object} analyticsData - Analytics data
+ * @param {string} exportsPath - Exports directory path
+ * @returns {Promise<Object>} Export result
+ */
+async function exportJSON(analyticsData, exportsPath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  const filename = `analytics-${timestamp}.json`;
+  const filePath = path.join(exportsPath, filename);
+
+  // Write JSON file
+  await fs.writeJSON(filePath, analyticsData, { spaces: 2 });
+
+  // Get file size
+  const stats = await fs.stat(filePath);
+  const sizeKB = (stats.size / 1024).toFixed(2);
+
+  return {
+    file: filePath,
+    size: `${sizeKB} KB`,
+    format: 'json'
+  };
+}
+
+/**
+ * Export analytics as CSV (multiple files)
+ * @param {Object} analyticsData - Analytics data
+ * @param {string} exportsPath - Exports directory path
+ * @returns {Promise<Object>} Export result
+ */
+async function exportCSV(analyticsData, exportsPath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  const files = [];
+
+  // Export overview
+  const overviewFile = path.join(exportsPath, `analytics-overview-${timestamp}.csv`);
+  await fs.writeFile(overviewFile, generateOverviewCSV(analyticsData.overview));
+  files.push(overviewFile);
+
+  // Export skip trends
+  const trendsFile = path.join(exportsPath, `analytics-skip-trends-${timestamp}.csv`);
+  await fs.writeFile(trendsFile, generateSkipTrendsCSV(analyticsData.skipTrends));
+  files.push(trendsFile);
+
+  // Export category preferences
+  const categoriesFile = path.join(exportsPath, `analytics-categories-${timestamp}.csv`);
+  await fs.writeFile(categoriesFile, generateCategoriesCSV(analyticsData.categoryPreferences));
+  files.push(categoriesFile);
+
+  // Export patterns
+  const patternsFile = path.join(exportsPath, `analytics-patterns-${timestamp}.csv`);
+  await fs.writeFile(patternsFile, generatePatternsCSV(analyticsData.patternDistribution, analyticsData.decayStatus));
+  files.push(patternsFile);
+
+  // Export effectiveness
+  const effectivenessFile = path.join(exportsPath, `analytics-effectiveness-${timestamp}.csv`);
+  await fs.writeFile(effectivenessFile, generateEffectivenessCSV(analyticsData.effectiveness));
+  files.push(effectivenessFile);
+
+  return {
+    files,
+    format: 'csv'
+  };
+}
+
+/**
+ * Generate overview CSV
+ * @param {Object} overview - Overview data
+ * @returns {string} CSV content
+ */
+function generateOverviewCSV(overview) {
+  const rows = [
+    ['Metric', 'Value', 'Unit'],
+    ['Total Sessions', overview.totalSessions, 'sessions'],
+    ['Total Skips', overview.totalSkips, 'questions'],
+    ['Manual Skips', overview.manualSkips, 'questions'],
+    ['Filtered Skips', overview.filteredSkips, 'questions'],
+    ['Total Answers', overview.totalAnswers, 'questions'],
+    ['Active Patterns', overview.activePatterns, 'patterns'],
+    ['Active Rules', overview.activeRules, 'rules'],
+    ['Learning Age', overview.learningAge, 'days']
+  ];
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate skip trends CSV
+ * @param {Array} skipTrends - Skip trends data
+ * @returns {string} CSV content
+ */
+function generateSkipTrendsCSV(skipTrends) {
+  const rows = [
+    ['Week', 'Week Number', 'Manual Skips', 'Filtered Skips', 'Total Skips', 'Skip Rate (%)']
+  ];
+
+  for (const trend of skipTrends) {
+    rows.push([
+      trend.week,
+      trend.weekNumber,
+      trend.manualSkips,
+      trend.filteredSkips,
+      trend.totalSkips,
+      trend.skipRate
+    ]);
+  }
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate categories CSV
+ * @param {Array} categories - Category preferences data
+ * @returns {string} CSV content
+ */
+function generateCategoriesCSV(categories) {
+  const rows = [
+    ['Category', 'Skips', 'Answers', 'Total', 'Skip Rate (%)', 'Level']
+  ];
+
+  for (const cat of categories) {
+    rows.push([
+      escapeCSV(cat.category),
+      cat.skips,
+      cat.answers,
+      cat.total,
+      cat.skipRate,
+      cat.level
+    ]);
+  }
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate patterns CSV
+ * @param {Object} patternDistribution - Pattern distribution data
+ * @param {Object} decayStatus - Decay status data
+ * @returns {string} CSV content
+ */
+function generatePatternsCSV(patternDistribution, decayStatus) {
+  const dist = patternDistribution.distribution || { high: 0, medium: 0, low: 0, veryLow: 0 };
+  const decay = decayStatus || { healthy: 0, warning: 0, critical: 0, recentlyRenewed: 0, avgAge: 0 };
+
+  const rows = [
+    ['Metric', 'Value', 'Description'],
+    ['Total Patterns', patternDistribution.totalPatterns || 0, 'All patterns'],
+    ['High Confidence (90%+)', dist.high, 'Very strong patterns'],
+    ['Medium Confidence (75-89%)', dist.medium, 'Strong patterns'],
+    ['Low Confidence (50-74%)', dist.low, 'Weak patterns'],
+    ['Very Low Confidence (<50%)', dist.veryLow, 'Very weak patterns'],
+    ['Average Confidence', (patternDistribution.avgConfidence || 0) + '%', 'Mean confidence score'],
+    ['At Risk', patternDistribution.atRiskCount || 0, 'Patterns at risk of removal'],
+    ['', '', ''],
+    ['Decay Status', '', ''],
+    ['Healthy Patterns', decay.healthy, 'Active and strong'],
+    ['Warning Patterns', decay.warning, 'Needs attention'],
+    ['Critical Patterns', decay.critical, 'May be removed soon'],
+    ['Recently Renewed', decay.recentlyRenewed, 'Last 30 days'],
+    ['Average Age', decay.avgAge + ' days', 'Mean pattern age']
+  ];
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Generate effectiveness CSV
+ * @param {Object} effectiveness - Effectiveness data
+ * @returns {string} CSV content
+ */
+function generateEffectivenessCSV(effectiveness) {
+  const rows = [
+    ['Metric', 'Value', 'Unit'],
+    ['Time Saved', effectiveness.timeSavedMinutes, 'minutes'],
+    ['Time Saved (Hours)', effectiveness.timeSavedHours, 'hours'],
+    ['Questions Filtered', effectiveness.questionsFiltered, 'questions'],
+    ['False Positives', effectiveness.falsePositives, 'questions'],
+    ['False Positive Rate', effectiveness.falsePositiveRate, '%'],
+    ['Pattern Accuracy', effectiveness.patternAccuracy, '%'],
+    ['Total Rule Applications', effectiveness.totalRuleApplications, 'applications'],
+    ['Avg Applications Per Rule', effectiveness.avgApplicationsPerRule, 'applications'],
+    ['Overall Effectiveness', effectiveness.overallEffectiveness, '%']
+  ];
+
+  return rows.map(row => row.join(',')).join('\n');
+}
+
+/**
+ * Escape CSV value
+ * @param {string} value - Value to escape
+ * @returns {string} Escaped value
+ */
+function escapeCSV(value) {
+  if (typeof value !== 'string') return value;
+
+  // Escape quotes and wrap in quotes if contains special chars
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    return '"' + value.replace(/"/g, '""') + '"';
+  }
+
+  return value;
+}
+
+module.exports = {
+  exportAnalytics
+};