flex-md 3.2.0 → 4.0.0

package/dist/tokens/improvements.js

@@ -0,0 +1,697 @@
+import { parseSystemPart } from './parser.js';
+import { detectSystemPartLevel } from './compliance.js';
+/**
+ * Main improvement detector
+ */
+export function detectImprovements(spec, targetLevel = 2) {
+    const improvements = [];
+    const antiPatterns = [];
+    const optimizations = [];
+    // 1. Check each section for improvements
+    for (const section of spec.sections) {
+        improvements.push(...detectSectionImprovements(section, targetLevel));
+        antiPatterns.push(...detectSectionAntiPatterns(section));
+    }
+    // 2. Detect spec-level optimizations
+    optimizations.push(...detectSpecOptimizations(spec));
+    // 3. Identify quick wins
+    const quickWins = improvements.filter(imp => imp.effort === 'trivial' || imp.effort === 'easy').filter(imp => imp.impact.confidenceGain >= 10 || imp.impact.estimateAccuracyGain >= 10);
+    // 4. Calculate summary
+    const summary = calculateImprovementSummary(improvements, quickWins);
+    return {
+        improvements: improvements.sort(byPriorityAndImpact),
+        quickWins: quickWins.sort(byImpact),
+        antiPatterns,
+        optimizations,
+        summary
+    };
+}
+/**
+ * Detect improvements for individual section
+ */
+function detectSectionImprovements(section, targetLevel) {
+    const improvements = [];
+    const kind = (section.kind || 'text');
+    const systemPart = parseSystemPart(section.instruction, kind);
+    const currentLevel = systemPart ? detectSystemPartLevel(systemPart, kind) : null;
+    // 1. Missing system part
+    if (!systemPart) {
+        improvements.push({
+            sectionName: section.name,
+            priority: section.required !== false ? 'critical' : 'high',
+            category: 'missing',
+            issue: 'No system part present',
+            impact: {
+                confidenceGain: 20,
+                cognitiveLoadChange: targetLevel === 1 ? 1 : targetLevel === 2 ? 3 : 5,
+                estimateAccuracyGain: 25,
+                description: 'Token estimation will use fallback values without system part'
+            },
+            suggestion: `Add system part for ${kind} section`,
+            before: section.instruction || '(no instruction)',
+            after: generateSuggestedInstruction(section, targetLevel),
+            effort: 'easy',
+            autoFixable: true
+        });
+        return improvements;
+    }
+    // 2. Vague or overly simple values
+    const vagueness = detectVagueness(systemPart, kind);
+    if (vagueness) {
+        vagueness.sectionName = section.name; // Fill in section name
+        improvements.push(vagueness);
+    }
+    // 3. Insufficient level for target
+    if (currentLevel !== null && currentLevel < targetLevel) {
+        improvements.push({
+            sectionName: section.name,
+            priority: section.required !== false ? 'high' : 'medium',
+            category: 'upgrade',
+            issue: `Current level (L${currentLevel}) below target (L${targetLevel})`,
+            impact: {
+                confidenceGain: (targetLevel - currentLevel) * 8,
+                cognitiveLoadChange: (targetLevel - currentLevel) * 2,
+                estimateAccuracyGain: (targetLevel - currentLevel) * 10,
+                description: `Upgrading to L${targetLevel} will improve estimation accuracy`
+            },
+            suggestion: `Upgrade from L${currentLevel} to L${targetLevel}`,
+            before: section.instruction,
+            after: upgradeInstruction(section, systemPart, currentLevel, targetLevel),
+            effort: targetLevel - currentLevel === 1 ? 'easy' : 'moderate',
+            autoFixable: true
+        });
+    }
+    // 4. Invalid ranges
+    const rangeIssue = detectRangeIssues(systemPart, section);
+    if (rangeIssue) {
+        improvements.push(rangeIssue);
+    }
+    // 5. Unreasonable values
+    const unreasonable = detectUnreasonableValues(systemPart, section);
+    if (unreasonable) {
+        improvements.push(unreasonable);
+    }
+    // 6. Missing guidance part
+    if (!systemPart.guidance && kind !== 'table' && kind !== 'ordered_table') {
+        improvements.push({
+            sectionName: section.name,
+            priority: 'low',
+            category: 'optimize',
+            issue: 'System part exists but no guidance for LLM',
+            impact: {
+                confidenceGain: 0,
+                cognitiveLoadChange: 1,
+                estimateAccuracyGain: 0,
+                description: 'Adding guidance helps LLM understand intent better'
+            },
+            suggestion: 'Add guidance after system part',
+            before: section.instruction,
+            after: `${systemPart.raw}. ${generateDefaultGuidance(kind)}`,
+            effort: 'easy',
+            autoFixable: true
+        });
+    }
+    return improvements;
+}
+/**
+ * Detect vagueness in system parts
+ */
+function detectVagueness(systemPart, kind) {
+    const { parsed } = systemPart;
+    // Check for overly vague "at least" with low minimum
+    if (parsed.type === 'items' && parsed.atLeast && parsed.min <= 2) {
+        return {
+            sectionName: '', // Will be filled by caller
+            priority: 'medium',
+            category: 'vague',
+            issue: `"at least ${parsed.min}" is too vague`,
+            impact: {
+                confidenceGain: 15,
+                cognitiveLoadChange: 1,
+                estimateAccuracyGain: 20,
+                description: 'Very low minimums create wide estimation ranges'
+            },
+            suggestion: 'Use specific range or higher minimum',
+            before: systemPart.raw,
+            after: `Items: ${Math.max(3, parsed.min)}-${Math.max(5, parsed.min + 2)}`,
+            effort: 'trivial',
+            autoFixable: true
+        };
+    }
+    // Check for overly wide ranges
+    if (parsed.type === 'items' && parsed.max !== null) {
+        const range = parsed.max - parsed.min;
+        if (range > 10) {
+            return {
+                sectionName: '',
+                priority: 'medium',
+                category: 'vague',
+                issue: `Range too wide (${parsed.min}-${parsed.max})`,
+                impact: {
+                    confidenceGain: 10,
+                    cognitiveLoadChange: 0,
+                    estimateAccuracyGain: 15,
+                    description: 'Wide ranges reduce estimation accuracy'
+                },
+                suggestion: 'Narrow the range to ≤5-7 items',
+                before: systemPart.raw,
+                after: `Items: ${parsed.min}-${Math.min(parsed.max, parsed.min + 5)}`,
+                effort: 'trivial',
+                autoFixable: true
+            };
+        }
+    }
+    // Check for vague text lengths
+    if (parsed.type === 'length' && ['moderate', 'detailed', 'extensive'].includes(parsed.value)) {
+        return {
+            sectionName: '',
+            priority: 'low',
+            category: 'vague',
+            issue: `"${parsed.value}" is generic - consider specific measurement`,
+            impact: {
+                confidenceGain: 8,
+                cognitiveLoadChange: 1,
+                estimateAccuracyGain: 10,
+                description: 'Specific measurements (sentences/paragraphs) are more precise'
+            },
+            suggestion: 'Use specific sentence or paragraph count',
+            before: systemPart.raw,
+            after: 'Length: 2-3 paragraphs',
+            effort: 'trivial',
+            autoFixable: true
+        };
+    }
+    return null;
+}
+/**
+ * Detect range issues (max < min, etc.)
+ */
+function detectRangeIssues(systemPart, section) {
+    const { parsed } = systemPart;
+    if (parsed.type === 'items' || parsed.type === 'lines') {
+        if (parsed.max !== null && parsed.max < parsed.min) {
+            return {
+                sectionName: section.name,
+                priority: 'critical',
+                category: 'fix',
+                issue: `Invalid range: max (${parsed.max}) < min (${parsed.min})`,
+                impact: {
+                    confidenceGain: 0,
+                    cognitiveLoadChange: 0,
+                    estimateAccuracyGain: 0,
+                    description: 'Invalid range will cause errors'
+                },
+                suggestion: 'Fix invalid range',
+                before: systemPart.raw,
+                after: `${parsed.type === 'items' ? 'Items' : 'Lines'}: ${parsed.min}-${parsed.min + 3}`,
+                effort: 'trivial',
+                autoFixable: true
+            };
+        }
+    }
+    if (parsed.type === 'table') {
+        const issues = [];
+        if (parsed.rows.max !== null && parsed.rows.max < parsed.rows.min) {
+            issues.push(`rows: ${parsed.rows.min}-${parsed.rows.max}`);
+        }
+        if (parsed.columns.max !== null && parsed.columns.max < parsed.columns.min) {
+            issues.push(`columns: ${parsed.columns.min}-${parsed.columns.max}`);
+        }
+        if (issues.length > 0) {
+            return {
+                sectionName: section.name,
+                priority: 'critical',
+                category: 'fix',
+                issue: `Invalid table range: ${issues.join(', ')}`,
+                impact: {
+                    confidenceGain: 0,
+                    cognitiveLoadChange: 0,
+                    estimateAccuracyGain: 0,
+                    description: 'Invalid range will cause errors'
+                },
+                suggestion: 'Fix invalid table dimensions',
+                before: systemPart.raw,
+                after: `Rows: ${parsed.rows.min}-${Math.max(parsed.rows.min + 2, parsed.rows.max || 0)}, Columns: ${parsed.columns.min}`,
+                effort: 'trivial',
+                autoFixable: true
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Detect unreasonable values
+ */
+function detectUnreasonableValues(systemPart, section) {
+    const { parsed } = systemPart;
+    if (parsed.type === 'items') {
+        if (parsed.min > 50) {
+            return {
+                sectionName: section.name,
+                priority: 'high',
+                category: 'fix',
+                issue: `${parsed.min} items seems unreasonably high`,
+                impact: {
+                    confidenceGain: 5,
+                    cognitiveLoadChange: -2,
+                    estimateAccuracyGain: 10,
+                    description: 'Very high item counts are unusual and may be errors'
+                },
+                suggestion: 'Verify item count or reduce',
+                before: systemPart.raw,
+                after: `Items: 10-15`,
+                effort: 'easy',
+                autoFixable: false
+            };
+        }
+    }
+    if (parsed.type === 'table') {
+        if (parsed.rows.min > 30 || parsed.columns.min > 15) {
+            return {
+                sectionName: section.name,
+                priority: 'high',
+                category: 'fix',
+                issue: `Table size (${parsed.rows.min}×${parsed.columns.min}) seems unreasonably large`,
+                impact: {
+                    confidenceGain: 5,
+                    cognitiveLoadChange: -2,
+                    estimateAccuracyGain: 10,
+                    description: 'Very large tables are difficult for LLMs to generate accurately'
+                },
+                suggestion: 'Consider reducing table size or splitting',
+                before: systemPart.raw,
+                after: `Rows: 5-10, Columns: ${Math.min(5, parsed.columns.min)}`,
+                effort: 'moderate',
+                autoFixable: false
+            };
+        }
+    }
+    if (parsed.type === 'lines') {
+        if (parsed.min > 200) {
+            return {
+                sectionName: section.name,
+                priority: 'medium',
+                category: 'fix',
+                issue: `${parsed.min} lines of code is very large`,
+                impact: {
+                    confidenceGain: 3,
+                    cognitiveLoadChange: -1,
+                    estimateAccuracyGain: 5,
+                    description: 'Very long code sections may exceed context limits'
+                },
+                suggestion: 'Consider breaking into multiple sections',
+                before: systemPart.raw,
+                after: `Lines: 30-50`,
+                effort: 'moderate',
+                autoFixable: false
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Detect anti-patterns
+ */
+function detectSectionAntiPatterns(section) {
+    const patterns = [];
+    const kind = (section.kind || 'text');
+    const systemPart = parseSystemPart(section.instruction, kind);
+    const isRequired = section.required !== false;
+    // Anti-pattern: Required section with no instruction at all
+    if (isRequired && !section.instruction) {
+        patterns.push({
+            sectionName: section.name,
+            pattern: 'required_no_instruction',
+            severity: 'error',
+            why: 'Required sections should always have instructions',
+            fix: 'Add instruction with system part and guidance',
+            example: 'Length: 2-3 paragraphs. Explain the methodology and findings.'
+        });
+    }
+    // Anti-pattern: System part without period separator before guidance
+    if (section.instruction && systemPart && systemPart.guidance === null) {
+        const hasMoreText = section.instruction.length > systemPart.raw.length + 5;
+        if (hasMoreText) {
+            patterns.push({
+                sectionName: section.name,
+                pattern: 'missing_separator',
+                severity: 'warning',
+                why: 'System part should end with ". " to separate from guidance',
+                fix: 'Add period and space after system part',
+                example: 'Items: 3-5. Focus on the most important points.'
+            });
+        }
+    }
+    // Anti-pattern: Optional section with higher compliance than required
+    if (!isRequired && systemPart) {
+        const level = detectSystemPartLevel(systemPart, kind);
+        if (level === 3) {
+            patterns.push({
+                sectionName: section.name,
+                pattern: 'optional_high_complexity',
+                severity: 'info',
+                why: "Optional sections typically don't need L3 precision",
+                fix: 'Consider downgrading to L2 to reduce cognitive load',
+                example: 'Items: 3-5 (instead of "Items: at least 3")'
+            });
+        }
+    }
+    // Anti-pattern: Table with only one dimension specified as range
+    if (systemPart?.parsed.type === 'table') {
+        const rowsHasRange = systemPart.parsed.rows.max !== null;
+        const columnsHasRange = systemPart.parsed.columns.max !== null;
+        if (rowsHasRange !== columnsHasRange) {
+            patterns.push({
+                sectionName: section.name,
+                pattern: 'asymmetric_table_spec',
+                severity: 'info',
+                why: 'Inconsistent precision between rows and columns',
+                fix: 'Either specify both as ranges or both as exact numbers',
+                example: 'Rows: 3-5, Columns: 3-4 (both ranges)'
+            });
+        }
+    }
+    // Anti-pattern: Using approximate (~) for small numbers
+    if (systemPart?.parsed.type === 'lines' && systemPart.parsed.approximate && systemPart.parsed.min < 20) {
+        patterns.push({
+            sectionName: section.name,
+            pattern: 'approximate_small_value',
+            severity: 'warning',
+            why: 'Approximate (~) should be used for larger values (50+)',
+            fix: 'Use exact number or range for small values',
+            example: 'Lines: 15-20 (instead of ~15)'
+        });
+    }
+    return patterns;
+}
+/**
+ * Detect spec-level optimizations
+ */
+function detectSpecOptimizations(spec) {
+    const opts = [];
+    if (spec.sections.length === 0)
+        return opts;
+    const firstKind = (spec.sections[0].kind || 'text');
+    // Optimization: All sections at L1, could upgrade key ones to L2
+    const levels = spec.sections
+        .map(s => parseSystemPart(s.instruction, (s.kind || 'text')))
+        .filter(sp => sp !== null)
+        .map(sp => detectSystemPartLevel(sp, firstKind));
+    const allL1 = levels.length > 0 && levels.every(l => l === 1);
+    if (allL1 && levels.length >= 3) {
+        opts.push({
+            type: 'rebalance',
+            scope: 'spec',
+            description: 'All sections are L1 - consider upgrading required sections to L2',
+            benefit: 'Better token estimation accuracy with minimal effort increase',
+            effort: 'easy',
+            sections: spec.sections.filter(s => s.required !== false).map(s => s.name)
+        });
+    }
+    // Optimization: Mix of L1, L2, L3 - could standardize
+    const hasL1 = levels.some(l => l === 1);
+    const hasL2 = levels.some(l => l === 2);
+    const hasL3 = levels.some(l => l === 3);
+    const varietyCount = [hasL1, hasL2, hasL3].filter(Boolean).length;
+    if (varietyCount === 3) {
+        opts.push({
+            type: 'rebalance',
+            scope: 'spec',
+            description: 'Spec has sections at L1, L2, and L3 - consider standardizing',
+            benefit: 'More consistent cognitive load and maintenance',
+            effort: 'moderate',
+            sections: undefined
+        });
+    }
+    // Optimization: Too many sections without system parts
+    const withoutSystemParts = spec.sections.filter(s => parseSystemPart(s.instruction, (s.kind || 'text')) === null);
+    if (withoutSystemParts.length > spec.sections.length * 0.3) {
+        opts.push({
+            type: 'simplify',
+            scope: 'spec',
+            description: `${withoutSystemParts.length} sections missing system parts`,
+            benefit: 'Adding system parts will greatly improve token estimation',
+            effort: 'easy',
+            sections: withoutSystemParts.map(s => s.name)
+        });
+    }
+    // Optimization: Very large spec (10+ sections)
+    if (spec.sections.length > 10) {
+        opts.push({
+            type: 'split',
+            scope: 'spec',
+            description: `Spec has ${spec.sections.length} sections - consider splitting`,
+            benefit: 'Smaller specs are easier to maintain and use',
+            effort: 'hard',
+            sections: undefined
+        });
+    }
+    // Optimization: All text sections could benefit from more specific lengths
+    const textSections = spec.sections.filter(s => (s.kind || 'text') === 'text');
+    const vagueLengths = textSections.filter(s => {
+        const sp = parseSystemPart(s.instruction, 'text');
+        return sp?.parsed.type === 'length' &&
+            ['brief', 'moderate', 'detailed', 'extensive'].includes(sp.parsed.value);
+    });
+    if (textSections.length > 0 && vagueLengths.length === textSections.length && textSections.length >= 3) {
+        opts.push({
+            type: 'simplify',
+            scope: 'spec',
+            description: 'All text sections use generic lengths (brief/moderate/etc)',
+            benefit: 'Upgrading to specific counts (1-2 sentences, 2-3 paragraphs) improves accuracy',
+            effort: 'easy',
+            sections: vagueLengths.map(s => s.name)
+        });
+    }
+    return opts;
+}
+/**
+ * Helper: Generate suggested instruction
+ */
+function generateSuggestedInstruction(section, level) {
+    const kind = (section.kind || 'text');
+    const systemPart = suggestSystemPartForLevel(kind, level);
+    const guidance = generateDefaultGuidance(kind);
+    if (section.instruction) {
+        return `${systemPart}. ${section.instruction}`;
+    }
+    return `${systemPart}. ${guidance}`;
+}
+/**
+ * Helper: Suggest system part for level
+ */
+function suggestSystemPartForLevel(kind, level) {
+    if (level <= 1) {
+        const defaults = {
+            'text': 'Length: brief',
+            'list': 'Items: 3',
+            'ordered_list': 'Items: 3',
+            'code': 'Lines: 10',
+            'table': 'Rows: 3, Columns: 3',
+            'ordered_table': 'Rows: 3, Columns: 3'
+        };
+        return defaults[kind] || 'Length: moderate';
+    }
+    if (level === 2) {
+        const defaults = {
+            'text': 'Length: 1-2 sentences',
+            'list': 'Items: 3-5',
+            'ordered_list': 'Items: 3-5',
+            'code': 'Lines: 10-20',
+            'table': 'Rows: 3-5, Columns: 3',
+            'ordered_table': 'Rows: 3-5, Columns: 3'
+        };
+        return defaults[kind] || 'Length: 1-2 sentences';
+    }
+    // Level 3
+    const defaults = {
+        'text': 'Length: 1-2 sentences',
+        'list': 'Items: at least 3',
+        'ordered_list': 'Items: at least 3',
+        'code': 'Lines: ~20',
+        'table': 'Rows: at least 3, Columns: 3',
+        'ordered_table': 'Rows: at least 3, Columns: 3'
+    };
+    return defaults[kind] || 'Length: 1-2 sentences';
+}
+/**
+ * Helper: Upgrade instruction to higher level
+ */
+function upgradeInstruction(section, systemPart, currentLevel, targetLevel) {
+    const { parsed, guidance } = systemPart;
+    let newSystemPart = '';
+    if (currentLevel === 1 && targetLevel >= 2) {
+        // L1 \u2192 L2: Add ranges
+        switch (parsed.type) {
+            case 'length':
+                newSystemPart = 'Length: 2-3 paragraphs';
+                break;
+            case 'items':
+                newSystemPart = `Items: ${parsed.min}-${parsed.min + 2}`;
+                break;
+            case 'lines':
+                newSystemPart = `Lines: ${parsed.min}-${parsed.min + 10}`;
+                break;
+            case 'table':
+                newSystemPart = `Rows: ${parsed.rows.min}-${parsed.rows.min + 2}, Columns: ${parsed.columns.min}`;
+                break;
+        }
+    }
+    else if (currentLevel === 2 && targetLevel === 3) {
+        // L2 \u2192 L3: Add "at least" or "~"
+        switch (parsed.type) {
+            case 'items':
+                newSystemPart = `Items: at least ${parsed.min}`;
+                break;
+            case 'lines':
+                newSystemPart = `Lines: ~${parsed.min}`;
+                break;
+            case 'table':
+                newSystemPart = `Rows: at least ${parsed.rows.min}, Columns: ${parsed.columns.min}`;
+                break;
+            default:
+                newSystemPart = systemPart.raw;
+        }
+    }
+    else {
+        newSystemPart = systemPart.raw;
+    }
+    return guidance ? `${newSystemPart}. ${guidance}` : newSystemPart;
+}
+/**
+ * Helper: Generate default guidance
+ */
+function generateDefaultGuidance(kind) {
+    const defaults = {
+        'text': 'Provide clear and concise explanation',
+        'list': 'Focus on the most important points',
+        'ordered_list': 'List in order of priority or sequence',
+        'table': 'Include relevant data with clear headers',
+        'ordered_table': 'Include relevant data with clear headers',
+        'code': 'Include comments and error handling'
+    };
+    return defaults[kind] || 'Provide relevant content';
+}
+/**
+ * Calculate improvement summary
+ */
+function calculateImprovementSummary(improvements, quickWins) {
+    const criticalCount = improvements.filter(i => i.priority === 'critical').length;
+    const potentialConfidenceGain = improvements.reduce((sum, i) => sum + i.impact.confidenceGain, 0);
+    let estimatedEffort = 'minimal';
+    if (improvements.length > 10)
+        estimatedEffort = 'significant';
+    else if (improvements.length > 5)
+        estimatedEffort = 'moderate';
+    return {
+        totalImprovements: improvements.length,
+        criticalCount,
+        potentialConfidenceGain: Math.min(100, potentialConfidenceGain),
+        quickWinCount: quickWins.length,
+        estimatedEffort
+    };
+}
+// Sorting functions
+function byPriorityAndImpact(a, b) {
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    const pDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (pDiff !== 0)
+        return pDiff;
+    return b.impact.confidenceGain - a.impact.confidenceGain;
+}
+function byImpact(a, b) {
+    return b.impact.confidenceGain - a.impact.confidenceGain;
+}
+/**
+ * Format improvement report
+ */
+export function formatImprovementReport(analysis) {
+    const lines = [];
+    lines.push('\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2551');
+    lines.push('\u2551      IMPROVEMENT DETECTION REPORT                \u2551');
+    lines.push('\u255a\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d');
+    lines.push('');
+    // Summary
+    lines.push('\ud83d\udcca SUMMARY');
+    lines.push('\u2500'.repeat(50));
+    lines.push(`Total improvements found:     ${analysis.summary.totalImprovements}`);
+    lines.push(`Critical issues:              ${analysis.summary.criticalCount}`);
+    lines.push(`Quick wins available:         ${analysis.summary.quickWinCount}`);
+    lines.push(`Potential confidence gain:    +${analysis.summary.potentialConfidenceGain}%`);
+    lines.push(`Estimated effort:             ${analysis.summary.estimatedEffort}`);
+    lines.push('');
+    // Quick Wins
+    if (analysis.quickWins.length > 0) {
+        lines.push('\u26a1 QUICK WINS (Low Effort, High Impact)');
+        lines.push('\u2500'.repeat(50));
+        analysis.quickWins.slice(0, 5).forEach((imp, i) => {
+            lines.push(`${i + 1}. "${imp.sectionName}" - ${imp.issue}`);
+            lines.push(`   Impact: +${imp.impact.confidenceGain}% confidence, +${imp.impact.estimateAccuracyGain}% accuracy`);
+            lines.push(`   Before: ${imp.before}`);
+            lines.push(`   After:  ${imp.after}`);
+            lines.push('');
+        });
+    }
+    // Critical Issues
+    const critical = analysis.improvements.filter(i => i.priority === 'critical');
+    if (critical.length > 0) {
+        lines.push('\ud83d\udd34 CRITICAL ISSUES');
+        lines.push('\u2500'.repeat(50));
+        critical.forEach((imp, i) => {
+            lines.push(`${i + 1}. "${imp.sectionName}" - ${imp.issue}`);
+            lines.push(`   Fix: ${imp.suggestion}`);
+            lines.push(`   Before: ${imp.before}`);
+            lines.push(`   After:  ${imp.after}`);
+            lines.push('');
+        });
+    }
+    // Anti-Patterns
+    if (analysis.antiPatterns.length > 0) {
+        lines.push('\u26a0\ufe0f  ANTI-PATTERNS DETECTED');
+        lines.push('\u2500'.repeat(50));
+        analysis.antiPatterns.forEach((ap, i) => {
+            const icon = ap.severity === 'error' ? '\u274c' : ap.severity === 'warning' ? '\u26a0\ufe0f' : '\u2139\ufe0f';
+            lines.push(`${i + 1}. ${icon} "${ap.sectionName}" - ${ap.pattern}`);
+            lines.push(`   Why: ${ap.why}`);
+            lines.push(`   Fix: ${ap.fix}`);
+            lines.push(`   Example: ${ap.example}`);
+            lines.push('');
+        });
+    }
+    // Optimizations
+    if (analysis.optimizations.length > 0) {
+        lines.push('\ud83d\udca1 OPTIMIZATION OPPORTUNITIES');
+        lines.push('\u2500'.repeat(50));
+        analysis.optimizations.forEach((opt, i) => {
+            lines.push(`${i + 1}. [${opt.type.toUpperCase()}] ${opt.description}`);
+            lines.push(`   Benefit: ${opt.benefit}`);
+            lines.push(`   Effort: ${opt.effort}`);
+            if (opt.sections) {
+                lines.push(`   Sections: ${opt.sections.join(', ')}`);
+            }
+            lines.push('');
+        });
+    }
+    // All Improvements (grouped by category)
+    lines.push('\ud83d\udccb ALL IMPROVEMENTS');
+    lines.push('\u2500'.repeat(50));
+    const byCategory = {
+        missing: analysis.improvements.filter(i => i.category === 'missing'),
+        vague: analysis.improvements.filter(i => i.category === 'vague'),
+        upgrade: analysis.improvements.filter(i => i.category === 'upgrade'),
+        fix: analysis.improvements.filter(i => i.category === 'fix'),
+        optimize: analysis.improvements.filter(i => i.category === 'optimize')
+    };
+    Object.entries(byCategory).forEach(([category, imps]) => {
+        if (imps.length > 0) {
+            lines.push(`\n${category.toUpperCase()} (${imps.length}):`);
+            imps.forEach(imp => {
+                const icon = imp.priority === 'critical' ? '\ud83d\udd34' :
+                    imp.priority === 'high' ? '\ud83d\udfe0' :
+                        imp.priority === 'medium' ? '\ud83d\udfe1' : '\ud83d\udfe2';
+                lines.push(`  ${icon} ${imp.sectionName}: ${imp.issue}`);
+            });
+        }
+    });
+    return lines.join('\n');
+}