@pennyfarthing/core 7.4.1 → 7.5.0

package/dist/scripts/job-fair-aggregator.js

@@ -0,0 +1,690 @@
+"use strict";
+/**
+ * Job-Fair Aggregator Module
+ *
+ * Story 7-4: Aggregate Job-Fair Results into Benchmark Statistics
+ * Story 7-5: Add Persona Differential Dimensions to Benchmarking
+ *
+ * Aggregates job-fair results across multiple themes into unified benchmark
+ * statistics with historical trend tracking and dimension-based analysis.
+ *
+ * Design decisions (from brainstorm):
+ * - Latest run per theme only (avoids duplicate counting)
+ * - Single-pass with pure functions (simple, testable)
+ * - Single history file for trends (aggregate/history.yaml)
+ * - Self-contained baseline (mean score as baseline reference)
+ * - Dimension grouping for comparative analysis (7-5)
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateJobFairResults = aggregateJobFairResults;
+exports.getBaselineComparison = getBaselineComparison;
+exports.getRoleStatistics = getRoleStatistics;
+exports.getTopPerformers = getTopPerformers;
+exports.getHistoricalTrend = getHistoricalTrend;
+exports.saveHistoricalSnapshot = saveHistoricalSnapshot;
+exports.aggregateByDimension = aggregateByDimension;
+exports.getDimensionValues = getDimensionValues;
+exports.generateDifferentialReport = generateDifferentialReport;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var url_1 = require("url");
+var yaml_1 = require("yaml");
+// ESM-compatible __dirname equivalent
+var __filename = (0, url_1.fileURLToPath)(import.meta.url);
+var __dirname = (0, path_1.dirname)(__filename);
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Parse theme name and timestamp from directory name
+ * Format: {theme}-{timestamp} e.g., "1984-20260106T015755Z"
+ */
+function parseDirectoryName(dirName) {
+    // Match pattern: anything-YYYYMMDD or anything-YYYYMMDDTHHMMSSz
+    var match = dirName.match(/^(.+)-(\d{8}(?:T\d{6}Z?|-\d{6})?)$/);
+    if (!match)
+        return null;
+    return { theme: match[1], timestamp: match[2] };
+}
+/**
+ * Get latest run directory for each theme
+ */
+function getLatestRunPerTheme(resultsDir) {
+    var themeLatest = new Map();
+    if (!(0, fs_1.existsSync)(resultsDir))
+        return new Map();
+    var entries = (0, fs_1.readdirSync)(resultsDir, { withFileTypes: true });
+    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var entry = entries_1[_i];
+        if (!entry.isDirectory())
+            continue;
+        var parsed = parseDirectoryName(entry.name);
+        if (!parsed)
+            continue;
+        var existing = themeLatest.get(parsed.theme);
+        if (!existing || parsed.timestamp > existing.timestamp) {
+            themeLatest.set(parsed.theme, { timestamp: parsed.timestamp, dirName: entry.name });
+        }
+    }
+    return new Map(Array.from(themeLatest.entries()).map(function (_a) {
+        var theme = _a[0], info = _a[1];
+        return [theme, info.dirName];
+    }));
+}
+/**
+ * Parse a summary.yaml file and extract scores
+ */
+function parseSummaryYaml(filePath, themeName) {
+    var _a, _b;
+    try {
+        var content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        var data = (0, yaml_1.parse)(content);
+        var theme = ((_a = data.meta) === null || _a === void 0 ? void 0 : _a.theme) || data.theme || themeName;
+        var timestamp = ((_b = data.meta) === null || _b === void 0 ? void 0 : _b.timestamp) || data.timestamp || new Date().toISOString();
+        var scores = [];
+        // Extract scores from matrix
+        if (data.matrix) {
+            if ('rows' in data.matrix && Array.isArray(data.matrix.rows)) {
+                // Format: { headers: [...], rows: [...] }
+                var roles = ['dev', 'reviewer', 'tea', 'sm'];
+                for (var _i = 0, _c = data.matrix.rows; _i < _c.length; _i++) {
+                    var row = _c[_i];
+                    for (var _d = 0, roles_1 = roles; _d < roles_1.length; _d++) {
+                        var role = roles_1[_d];
+                        var score = row[role];
+                        if (typeof score === 'number') {
+                            scores.push({ character: row.character, role: role, score: score });
+                        }
+                    }
+                }
+            }
+            else {
+                // Format: { alice: { dev: 85.5, reviewer: 72.0 }, ... }
+                var matrixObj = data.matrix;
+                for (var _e = 0, _f = Object.entries(matrixObj); _e < _f.length; _e++) {
+                    var _g = _f[_e], character = _g[0], roleScores = _g[1];
+                    if (character === 'headers' || character === 'rows')
+                        continue;
+                    for (var _h = 0, _j = Object.entries(roleScores); _h < _j.length; _h++) {
+                        var _k = _j[_h], role = _k[0], score = _k[1];
+                        if (typeof score === 'number') {
+                            scores.push({ character: character, role: role, score: score });
+                        }
+                    }
+                }
+            }
+        }
+        // Fallback: extract from role_rankings if matrix didn't yield scores
+        if (scores.length === 0 && data.role_rankings) {
+            for (var _l = 0, _m = Object.entries(data.role_rankings); _l < _m.length; _l++) {
+                var _o = _m[_l], role = _o[0], rankings = _o[1];
+                for (var _p = 0, rankings_1 = rankings; _p < rankings_1.length; _p++) {
+                    var entry = rankings_1[_p];
+                    scores.push({ character: entry.character, role: role, score: entry.score });
+                }
+            }
+        }
+        return {
+            theme: theme,
+            timestamp: timestamp,
+            champions: data.champions || {},
+            scores: scores,
+        };
+    }
+    catch (_q) {
+        // Skip malformed YAML
+        return null;
+    }
+}
+/**
+ * Calculate standard deviation
+ */
+function calculateStdDev(values, mean) {
+    if (values.length <= 1)
+        return 0;
+    var squaredDiffs = values.map(function (v) { return Math.pow(v - mean, 2); });
+    var variance = squaredDiffs.reduce(function (a, b) { return a + b; }, 0) / values.length;
+    return Math.sqrt(variance);
+}
+/**
+ * Calculate variance
+ */
+function calculateVariance(values, mean) {
+    if (values.length <= 1)
+        return 0;
+    var squaredDiffs = values.map(function (v) { return Math.pow(v - mean, 2); });
+    return squaredDiffs.reduce(function (a, b) { return a + b; }, 0) / values.length;
+}
+/**
+ * Get path to history file
+ */
+function getHistoryFilePath(resultsDir) {
+    return (0, path_1.join)(resultsDir, 'aggregate', 'history.yaml');
+}
+/**
+ * Load historical trend data
+ */
+function loadHistoricalTrend(resultsDir) {
+    var historyPath = getHistoryFilePath(resultsDir);
+    if (!(0, fs_1.existsSync)(historyPath))
+        return [];
+    try {
+        var content = (0, fs_1.readFileSync)(historyPath, 'utf-8');
+        var data = (0, yaml_1.parse)(content);
+        return data.snapshots || [];
+    }
+    catch (_a) {
+        return [];
+    }
+}
+// ============================================================================
+// Main Exported Functions
+// ============================================================================
+/**
+ * Aggregate job-fair results from all themes
+ *
+ * AC1: Job-fair results contribute to overall benchmark statistics
+ */
+function aggregateJobFairResults(resultsDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var latestRuns, allResults, _i, latestRuns_1, _a, theme, dirName, summaryPath, result, scoresByRole, _b, allResults_1, result, _c, _d, _e, character, role, score, allScores, overallMean, byRole, _f, scoresByRole_1, _g, role, entries, scores, mean, stdDev, sorted, characterAverages, _h, allResults_2, result, _j, _k, _l, character, score, key, overallChampions, historicalTrend;
+        return __generator(this, function (_m) {
+            latestRuns = getLatestRunPerTheme(resultsDir);
+            allResults = [];
+            // Parse all theme summaries
+            for (_i = 0, latestRuns_1 = latestRuns; _i < latestRuns_1.length; _i++) {
+                _a = latestRuns_1[_i], theme = _a[0], dirName = _a[1];
+                summaryPath = (0, path_1.join)(resultsDir, dirName, 'summary.yaml');
+                if (!(0, fs_1.existsSync)(summaryPath))
+                    continue;
+                result = parseSummaryYaml(summaryPath, theme);
+                if (result && result.scores.length > 0) {
+                    allResults.push(result);
+                }
+            }
+            scoresByRole = new Map();
+            for (_b = 0, allResults_1 = allResults; _b < allResults_1.length; _b++) {
+                result = allResults_1[_b];
+                for (_c = 0, _d = result.scores; _c < _d.length; _c++) {
+                    _e = _d[_c], character = _e.character, role = _e.role, score = _e.score;
+                    if (!scoresByRole.has(role)) {
+                        scoresByRole.set(role, []);
+                    }
+                    scoresByRole.get(role).push({ character: character, theme: result.theme, score: score });
+                }
+            }
+            allScores = Array.from(scoresByRole.values()).flat().map(function (s) { return s.score; });
+            overallMean = allScores.length > 0
+                ? allScores.reduce(function (a, b) { return a + b; }, 0) / allScores.length
+                : 0;
+            byRole = {};
+            for (_f = 0, scoresByRole_1 = scoresByRole; _f < scoresByRole_1.length; _f++) {
+                _g = scoresByRole_1[_f], role = _g[0], entries = _g[1];
+                scores = entries.map(function (e) { return e.score; });
+                mean = scores.reduce(function (a, b) { return a + b; }, 0) / scores.length;
+                stdDev = calculateStdDev(scores, mean);
+                sorted = __spreadArray([], entries, true).sort(function (a, b) { return b.score - a.score; });
+                byRole[role] = {
+                    mean_score: mean,
+                    std_dev: stdDev,
+                    baseline_comparison: mean - overallMean,
+                    top_performers: sorted.slice(0, 5).map(function (e) { return ({
+                        character: e.character,
+                        theme: e.theme,
+                        score: e.score,
+                    }); }),
+                };
+            }
+            characterAverages = new Map();
+            for (_h = 0, allResults_2 = allResults; _h < allResults_2.length; _h++) {
+                result = allResults_2[_h];
+                for (_j = 0, _k = result.scores; _j < _k.length; _j++) {
+                    _l = _k[_j], character = _l.character, score = _l.score;
+                    key = "".concat(character, "|").concat(result.theme);
+                    if (!characterAverages.has(key)) {
+                        characterAverages.set(key, { theme: result.theme, scores: [] });
+                    }
+                    characterAverages.get(key).scores.push(score);
+                }
+            }
+            overallChampions = Array.from(characterAverages.entries())
+                .map(function (_a) {
+                var key = _a[0], data = _a[1];
+                var character = key.split('|')[0];
+                var avgScore = data.scores.reduce(function (a, b) { return a + b; }, 0) / data.scores.length;
+                return { character: character, theme: data.theme, avg_score: avgScore };
+            })
+                .sort(function (a, b) { return b.avg_score - a.avg_score; })
+                .slice(0, 10);
+            historicalTrend = loadHistoricalTrend(resultsDir);
+            return [2 /*return*/, {
+                    themes_included: allResults.map(function (r) { return r.theme; }),
+                    last_updated: new Date().toISOString(),
+                    by_role: byRole,
+                    overall_champions: overallChampions,
+                    historical_trend: historicalTrend,
+                }];
+        });
+    });
+}
+/**
+ * Get baseline comparison for a specific role
+ *
+ * AC2: Baseline calculations incorporate job-fair control runs
+ */
+function getBaselineComparison(role, resultsDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stats;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, aggregateJobFairResults(resultsDir)];
+                case 1:
+                    stats = _c.sent();
+                    return [2 /*return*/, (_b = (_a = stats.by_role[role]) === null || _a === void 0 ? void 0 : _a.baseline_comparison) !== null && _b !== void 0 ? _b : null];
+            }
+        });
+    });
+}
+/**
+ * Get statistics for a specific role
+ *
+ * AC3: Scenario performance tracked across themes
+ */
+function getRoleStatistics(role, resultsDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stats;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, aggregateJobFairResults(resultsDir)];
+                case 1:
+                    stats = _a.sent();
+                    return [2 /*return*/, stats.by_role[role] || {
+                            mean_score: 0,
+                            std_dev: 0,
+                            baseline_comparison: null,
+                            top_performers: [],
+                        }];
+            }
+        });
+    });
+}
+/**
+ * Get top performers for a specific role
+ *
+ * AC4: Summary statistics available (mean by role, variance, top performers)
+ */
+function getTopPerformers(role, limit, resultsDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stats, roleStats;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, aggregateJobFairResults(resultsDir)];
+                case 1:
+                    stats = _a.sent();
+                    roleStats = stats.by_role[role];
+                    if (!roleStats)
+                        return [2 /*return*/, []];
+                    return [2 /*return*/, roleStats.top_performers.slice(0, limit)];
+            }
+        });
+    });
+}
+/**
+ * Get historical trend data, optionally filtered by role
+ *
+ * AC5: Historical trend tracking for benchmark quality
+ */
+function getHistoricalTrend(role, resultsDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var trend;
+        return __generator(this, function (_a) {
+            trend = loadHistoricalTrend(resultsDir);
+            if (!role)
+                return [2 /*return*/, trend];
+            // Filter to role-specific points if role is specified
+            return [2 /*return*/, trend.filter(function (point) { return !point.role || point.role === role; })];
+        });
+    });
+}
+/**
+ * Save a historical snapshot of current aggregate stats
+ *
+ * AC5: Historical trend tracking for benchmark quality
+ */
+function saveHistoricalSnapshot(resultsDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stats, roleMeans, overallMean, overallVariance, newPoint, existingTrend, aggregateDir, historyPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, aggregateJobFairResults(resultsDir)];
+                case 1:
+                    stats = _a.sent();
+                    roleMeans = Object.values(stats.by_role).map(function (r) { return r.mean_score; });
+                    overallMean = roleMeans.length > 0
+                        ? roleMeans.reduce(function (a, b) { return a + b; }, 0) / roleMeans.length
+                        : 0;
+                    overallVariance = calculateVariance(roleMeans, overallMean);
+                    newPoint = {
+                        date: new Date().toISOString().split('T')[0],
+                        mean: overallMean,
+                        variance: overallVariance,
+                    };
+                    existingTrend = loadHistoricalTrend(resultsDir);
+                    existingTrend.push(newPoint);
+                    aggregateDir = (0, path_1.join)(resultsDir, 'aggregate');
+                    if (!(0, fs_1.existsSync)(aggregateDir)) {
+                        (0, fs_1.mkdirSync)(aggregateDir, { recursive: true });
+                    }
+                    historyPath = getHistoryFilePath(resultsDir);
+                    (0, fs_1.writeFileSync)(historyPath, (0, yaml_1.stringify)({ snapshots: existingTrend }));
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// ============================================================================
+// Story 7-5: Dimension Aggregation Functions
+// ============================================================================
+/** Default path to themes directory */
+var DEFAULT_THEMES_DIR = (0, path_1.join)(__dirname, '../../../../pennyfarthing-dist/personas/themes');
+/**
+ * Load dimensions from a theme YAML file
+ */
+function loadThemeDimensions(themeName, themesDir) {
+    var _a;
+    if (themesDir === void 0) { themesDir = DEFAULT_THEMES_DIR; }
+    var themePath = (0, path_1.join)(themesDir, "".concat(themeName, ".yaml"));
+    if (!(0, fs_1.existsSync)(themePath))
+        return null;
+    try {
+        var content = (0, fs_1.readFileSync)(themePath, 'utf-8');
+        var data = (0, yaml_1.parse)(content);
+        return ((_a = data.theme) === null || _a === void 0 ? void 0 : _a.dimensions) || null;
+    }
+    catch (_b) {
+        return null;
+    }
+}
+/**
+ * Calculate statistical significance using simplified t-test approximation
+ * Returns significance level based on effect size and sample sizes
+ */
+function calculateSignificance(mean1, mean2, std1, std2, n1, n2) {
+    if (n1 < 2 || n2 < 2)
+        return 'not_significant';
+    var pooledStd = Math.sqrt(((n1 - 1) * std1 * std1 + (n2 - 1) * std2 * std2) / (n1 + n2 - 2));
+    if (pooledStd === 0)
+        return 'not_significant';
+    // Calculate effect size (Cohen's d)
+    var effectSize = Math.abs(mean1 - mean2) / pooledStd;
+    // Effect size thresholds: small=0.2, medium=0.5, large=0.8
+    if (effectSize >= 0.8)
+        return 'significant';
+    if (effectSize >= 0.5)
+        return 'marginal';
+    return 'not_significant';
+}
+/**
+ * Aggregate job-fair results by a specific dimension
+ *
+ * Story 7-5: AC - Job-fair aggregator groups results by dimension
+ */
+function aggregateByDimension(dimension_1, resultsDir_1) {
+    return __awaiter(this, arguments, void 0, function (dimension, resultsDir, themesDir) {
+        var latestRuns, themesByValue, themeScores, _i, latestRuns_2, theme, dimensions, value, _a, latestRuns_3, _b, theme, dirName, summaryPath, result, values, _c, themesByValue_1, _d, value, themes, roleScores, totalScores, _e, themes_1, theme, scores, _f, scores_1, _g, role, score, byRole, _h, roleScores_1, _j, role, scores, mean, stdDev, overallMean, comparisons, i, j, a, b, allRoles, roleComparisons, _k, allRoles_1, role, aRole, bRole, delta, significance, overallDelta, aScores, bScores, aStd, bStd, overallSignificance;
+        if (themesDir === void 0) { themesDir = DEFAULT_THEMES_DIR; }
+        return __generator(this, function (_l) {
+            latestRuns = getLatestRunPerTheme(resultsDir);
+            themesByValue = new Map();
+            themeScores = new Map();
+            for (_i = 0, latestRuns_2 = latestRuns; _i < latestRuns_2.length; _i++) {
+                theme = latestRuns_2[_i][0];
+                dimensions = loadThemeDimensions(theme, themesDir);
+                if (!dimensions)
+                    continue;
+                value = dimensions[dimension];
+                if (!value)
+                    continue;
+                if (!themesByValue.has(value)) {
+                    themesByValue.set(value, []);
+                }
+                themesByValue.get(value).push(theme);
+            }
+            // Parse scores for each theme
+            for (_a = 0, latestRuns_3 = latestRuns; _a < latestRuns_3.length; _a++) {
+                _b = latestRuns_3[_a], theme = _b[0], dirName = _b[1];
+                summaryPath = (0, path_1.join)(resultsDir, dirName, 'summary.yaml');
+                if (!(0, fs_1.existsSync)(summaryPath))
+                    continue;
+                result = parseSummaryYaml(summaryPath, theme);
+                if (result && result.scores.length > 0) {
+                    themeScores.set(theme, result.scores.map(function (s) { return ({ role: s.role, score: s.score }); }));
+                }
+            }
+            values = [];
+            for (_c = 0, themesByValue_1 = themesByValue; _c < themesByValue_1.length; _c++) {
+                _d = themesByValue_1[_c], value = _d[0], themes = _d[1];
+                roleScores = new Map();
+                totalScores = [];
+                for (_e = 0, themes_1 = themes; _e < themes_1.length; _e++) {
+                    theme = themes_1[_e];
+                    scores = themeScores.get(theme);
+                    if (!scores)
+                        continue;
+                    for (_f = 0, scores_1 = scores; _f < scores_1.length; _f++) {
+                        _g = scores_1[_f], role = _g.role, score = _g.score;
+                        if (!roleScores.has(role)) {
+                            roleScores.set(role, []);
+                        }
+                        roleScores.get(role).push(score);
+                        totalScores.push(score);
+                    }
+                }
+                byRole = {};
+                for (_h = 0, roleScores_1 = roleScores; _h < roleScores_1.length; _h++) {
+                    _j = roleScores_1[_h], role = _j[0], scores = _j[1];
+                    mean = scores.reduce(function (a, b) { return a + b; }, 0) / scores.length;
+                    stdDev = calculateStdDev(scores, mean);
+                    byRole[role] = { mean_score: mean, std_dev: stdDev, n: scores.length };
+                }
+                overallMean = totalScores.length > 0
+                    ? totalScores.reduce(function (a, b) { return a + b; }, 0) / totalScores.length
+                    : 0;
+                values.push({
+                    value: value,
+                    themes: themes,
+                    sample_size: totalScores.length,
+                    by_role: byRole,
+                    overall_mean: overallMean,
+                });
+            }
+            comparisons = [];
+            for (i = 0; i < values.length; i++) {
+                for (j = i + 1; j < values.length; j++) {
+                    a = values[i];
+                    b = values[j];
+                    allRoles = new Set(__spreadArray(__spreadArray([], Object.keys(a.by_role), true), Object.keys(b.by_role), true));
+                    roleComparisons = {};
+                    for (_k = 0, allRoles_1 = allRoles; _k < allRoles_1.length; _k++) {
+                        role = allRoles_1[_k];
+                        aRole = a.by_role[role];
+                        bRole = b.by_role[role];
+                        if (aRole && bRole) {
+                            delta = aRole.mean_score - bRole.mean_score;
+                            significance = calculateSignificance(aRole.mean_score, bRole.mean_score, aRole.std_dev, bRole.std_dev, aRole.n, bRole.n);
+                            roleComparisons[role] = { delta: delta, significance: significance };
+                        }
+                    }
+                    overallDelta = a.overall_mean - b.overall_mean;
+                    aScores = Object.values(a.by_role);
+                    bScores = Object.values(b.by_role);
+                    aStd = aScores.length > 0
+                        ? Math.sqrt(aScores.reduce(function (sum, r) { return sum + r.std_dev * r.std_dev; }, 0) / aScores.length)
+                        : 0;
+                    bStd = bScores.length > 0
+                        ? Math.sqrt(bScores.reduce(function (sum, r) { return sum + r.std_dev * r.std_dev; }, 0) / bScores.length)
+                        : 0;
+                    overallSignificance = calculateSignificance(a.overall_mean, b.overall_mean, aStd, bStd, a.sample_size, b.sample_size);
+                    comparisons.push({
+                        dimension: dimension,
+                        value_a: a.value,
+                        value_b: b.value,
+                        delta: overallDelta,
+                        significance: overallSignificance,
+                        by_role: roleComparisons,
+                    });
+                }
+            }
+            return [2 /*return*/, {
+                    dimension: dimension,
+                    last_updated: new Date().toISOString(),
+                    values: values,
+                    comparisons: comparisons,
+                }];
+        });
+    });
+}
+/**
+ * Get all available dimension values with theme counts
+ *
+ * Useful for API endpoints to show available filter options
+ */
+function getDimensionValues(dimension_1) {
+    return __awaiter(this, arguments, void 0, function (dimension, themesDir) {
+        var valueCounts, entries, _i, entries_2, entry, themeName, dimensions, value;
+        if (themesDir === void 0) { themesDir = DEFAULT_THEMES_DIR; }
+        return __generator(this, function (_a) {
+            valueCounts = new Map();
+            if (!(0, fs_1.existsSync)(themesDir))
+                return [2 /*return*/, []];
+            entries = (0, fs_1.readdirSync)(themesDir, { withFileTypes: true });
+            for (_i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+                entry = entries_2[_i];
+                if (!entry.isFile() || !entry.name.endsWith('.yaml'))
+                    continue;
+                themeName = entry.name.replace('.yaml', '');
+                dimensions = loadThemeDimensions(themeName, themesDir);
+                if (dimensions && dimensions[dimension]) {
+                    value = dimensions[dimension];
+                    valueCounts.set(value, (valueCounts.get(value) || 0) + 1);
+                }
+            }
+            return [2 /*return*/, Array.from(valueCounts.entries())
+                    .map(function (_a) {
+                    var value = _a[0], theme_count = _a[1];
+                    return ({ value: value, theme_count: theme_count });
+                })
+                    .sort(function (a, b) { return b.theme_count - a.theme_count; })];
+        });
+    });
+}
+/**
+ * Generate a differential report comparing dimension values
+ *
+ * Story 7-5: AC - Differential report shows performance by dimension value
+ */
+function generateDifferentialReport(dimension_1, resultsDir_1) {
+    return __awaiter(this, arguments, void 0, function (dimension, resultsDir, themesDir) {
+        var stats, lines, sortedValues, _i, sortedValues_1, v, _a, _b, _c, role, roleStats, _d, _e, comp, sigLabel, direction, _f, _g, _h, role, roleComp;
+        if (themesDir === void 0) { themesDir = DEFAULT_THEMES_DIR; }
+        return __generator(this, function (_j) {
+            switch (_j.label) {
+                case 0: return [4 /*yield*/, aggregateByDimension(dimension, resultsDir, themesDir)];
+                case 1:
+                    stats = _j.sent();
+                    lines = [
+                        "# Differential Report: ".concat(dimension),
+                        '',
+                        "Generated: ".concat(stats.last_updated),
+                        '',
+                        '## Summary by Value',
+                        '',
+                    ];
+                    sortedValues = __spreadArray([], stats.values, true).sort(function (a, b) { return b.overall_mean - a.overall_mean; });
+                    for (_i = 0, sortedValues_1 = sortedValues; _i < sortedValues_1.length; _i++) {
+                        v = sortedValues_1[_i];
+                        lines.push("### ".concat(v.value));
+                        lines.push("- Themes: ".concat(v.themes.length, " (").concat(v.themes.join(', '), ")"));
+                        lines.push("- Sample size: ".concat(v.sample_size));
+                        lines.push("- Overall mean: ".concat(v.overall_mean.toFixed(2)));
+                        lines.push('');
+                        lines.push('| Role | Mean | Std Dev | N |');
+                        lines.push('|------|------|---------|---|');
+                        for (_a = 0, _b = Object.entries(v.by_role); _a < _b.length; _a++) {
+                            _c = _b[_a], role = _c[0], roleStats = _c[1];
+                            lines.push("| ".concat(role, " | ").concat(roleStats.mean_score.toFixed(2), " | ").concat(roleStats.std_dev.toFixed(2), " | ").concat(roleStats.n, " |"));
+                        }
+                        lines.push('');
+                    }
+                    lines.push('## Pairwise Comparisons');
+                    lines.push('');
+                    for (_d = 0, _e = stats.comparisons; _d < _e.length; _d++) {
+                        comp = _e[_d];
+                        sigLabel = comp.significance === 'significant' ? '**SIGNIFICANT**'
+                            : comp.significance === 'marginal' ? '*marginal*'
+                                : 'not significant';
+                        direction = comp.delta > 0 ? '>' : comp.delta < 0 ? '<' : '=';
+                        lines.push("### ".concat(comp.value_a, " ").concat(direction, " ").concat(comp.value_b));
+                        lines.push("- Delta: ".concat(comp.delta > 0 ? '+' : '').concat(comp.delta.toFixed(2), " (").concat(sigLabel, ")"));
+                        lines.push('');
+                        if (Object.keys(comp.by_role).length > 0) {
+                            lines.push('| Role | Delta | Significance |');
+                            lines.push('|------|-------|--------------|');
+                            for (_f = 0, _g = Object.entries(comp.by_role); _f < _g.length; _f++) {
+                                _h = _g[_f], role = _h[0], roleComp = _h[1];
+                                lines.push("| ".concat(role, " | ").concat(roleComp.delta > 0 ? '+' : '').concat(roleComp.delta.toFixed(2), " | ").concat(roleComp.significance, " |"));
+                            }
+                            lines.push('');
+                        }
+                    }
+                    return [2 /*return*/, lines.join('\n')];
+            }
+        });
+    });
+}