@pennyfarthing/core 7.5.0 → 7.6.1

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

@@ -1,690 +0,0 @@
-"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')];
-            }
-        });
-    });
-}