@pennyfarthing/core 7.4.0 → 7.5.0

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Job-Fair Aggregator Module
  *
@@ -14,13 +15,68 @@
  * - Self-contained baseline (mean score as baseline reference)
  * - Dimension grouping for comparative analysis (7-5)
  */
-import { readdirSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+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
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+var __filename = (0, url_1.fileURLToPath)(import.meta.url);
+var __dirname = (0, path_1.dirname)(__filename);
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -30,7 +86,7 @@ const __dirname = dirname(__filename);
  */
 function parseDirectoryName(dirName) {
     // Match pattern: anything-YYYYMMDD or anything-YYYYMMDDTHHMMSSz
-    const match = dirName.match(/^(.+)-(\d{8}(?:T\d{6}Z?|-\d{6})?)$/);
+    var match = dirName.match(/^(.+)-(\d{8}(?:T\d{6}Z?|-\d{6})?)$/);
     if (!match)
         return null;
     return { theme: match[1], timestamp: match[2] };
@@ -39,56 +95,65 @@ function parseDirectoryName(dirName) {
  * Get latest run directory for each theme
  */
 function getLatestRunPerTheme(resultsDir) {
-    const themeLatest = new Map();
-    if (!existsSync(resultsDir))
+    var themeLatest = new Map();
+    if (!(0, fs_1.existsSync)(resultsDir))
         return new Map();
-    const entries = readdirSync(resultsDir, { withFileTypes: true });
-    for (const entry of entries) {
+    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;
-        const parsed = parseDirectoryName(entry.name);
+        var parsed = parseDirectoryName(entry.name);
         if (!parsed)
             continue;
-        const existing = themeLatest.get(parsed.theme);
+        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(([theme, info]) => [theme, info.dirName]));
+    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 {
-        const content = readFileSync(filePath, 'utf-8');
-        const data = parseYaml(content);
-        const theme = data.meta?.theme || data.theme || themeName;
-        const timestamp = data.meta?.timestamp || data.timestamp || new Date().toISOString();
-        const scores = [];
+        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: [...] }
-                const roles = ['dev', 'reviewer', 'tea', 'sm'];
-                for (const row of data.matrix.rows) {
-                    for (const role of roles) {
-                        const score = row[role];
+                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, score });
+                            scores.push({ character: row.character, role: role, score: score });
                         }
                     }
                 }
             }
             else {
                 // Format: { alice: { dev: 85.5, reviewer: 72.0 }, ... }
-                const matrixObj = data.matrix;
-                for (const [character, roleScores] of Object.entries(matrixObj)) {
+                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 (const [role, score] of Object.entries(roleScores)) {
+                    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, role, score });
+                            scores.push({ character: character, role: role, score: score });
                         }
                     }
                 }
@@ -96,20 +161,22 @@ function parseSummaryYaml(filePath, themeName) {
         }
         // Fallback: extract from role_rankings if matrix didn't yield scores
         if (scores.length === 0 && data.role_rankings) {
-            for (const [role, rankings] of Object.entries(data.role_rankings)) {
-                for (const entry of rankings) {
-                    scores.push({ character: entry.character, role, score: entry.score });
+            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,
-            timestamp,
+            theme: theme,
+            timestamp: timestamp,
             champions: data.champions || {},
-            scores,
+            scores: scores,
         };
     }
-    catch {
+    catch (_q) {
         // Skip malformed YAML
         return null;
     }
@@ -120,8 +187,8 @@ function parseSummaryYaml(filePath, themeName) {
 function calculateStdDev(values, mean) {
     if (values.length <= 1)
         return 0;
-    const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
-    const variance = squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
+    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);
 }
 /**
@@ -130,28 +197,28 @@ function calculateStdDev(values, mean) {
 function calculateVariance(values, mean) {
     if (values.length <= 1)
         return 0;
-    const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
-    return squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
+    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 join(resultsDir, 'aggregate', 'history.yaml');
+    return (0, path_1.join)(resultsDir, 'aggregate', 'history.yaml');
 }
 /**
  * Load historical trend data
  */
 function loadHistoricalTrend(resultsDir) {
-    const historyPath = getHistoryFilePath(resultsDir);
-    if (!existsSync(historyPath))
+    var historyPath = getHistoryFilePath(resultsDir);
+    if (!(0, fs_1.existsSync)(historyPath))
         return [];
     try {
-        const content = readFileSync(historyPath, 'utf-8');
-        const data = parseYaml(content);
+        var content = (0, fs_1.readFileSync)(historyPath, 'utf-8');
+        var data = (0, yaml_1.parse)(content);
         return data.snapshots || [];
     }
-    catch {
+    catch (_a) {
         return [];
     }
 }
@@ -163,177 +230,224 @@ function loadHistoricalTrend(resultsDir) {
  *
  * AC1: Job-fair results contribute to overall benchmark statistics
  */
-export async function aggregateJobFairResults(resultsDir) {
-    const latestRuns = getLatestRunPerTheme(resultsDir);
-    const allResults = [];
-    // Parse all theme summaries
-    for (const [theme, dirName] of latestRuns) {
-        const summaryPath = join(resultsDir, dirName, 'summary.yaml');
-        if (!existsSync(summaryPath))
-            continue;
-        const result = parseSummaryYaml(summaryPath, theme);
-        if (result && result.scores.length > 0) {
-            allResults.push(result);
-        }
-    }
-    // Collect scores by role
-    const scoresByRole = new Map();
-    for (const result of allResults) {
-        for (const { character, role, score } of result.scores) {
-            if (!scoresByRole.has(role)) {
-                scoresByRole.set(role, []);
+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.get(role).push({ character, theme: result.theme, score });
-        }
-    }
-    // Calculate overall mean for baseline
-    const allScores = Array.from(scoresByRole.values()).flat().map(s => s.score);
-    const overallMean = allScores.length > 0
-        ? allScores.reduce((a, b) => a + b, 0) / allScores.length
-        : 0;
-    // Build by_role stats
-    const byRole = {};
-    for (const [role, entries] of scoresByRole) {
-        const scores = entries.map(e => e.score);
-        const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
-        const stdDev = calculateStdDev(scores, mean);
-        // Sort by score descending for top performers
-        const sorted = [...entries].sort((a, b) => b.score - a.score);
-        byRole[role] = {
-            mean_score: mean,
-            std_dev: stdDev,
-            baseline_comparison: mean - overallMean,
-            top_performers: sorted.slice(0, 5).map(e => ({
-                character: e.character,
-                theme: e.theme,
-                score: e.score,
-            })),
-        };
-    }
-    // Calculate overall champions (best average across roles per character+theme)
-    const characterAverages = new Map();
-    for (const result of allResults) {
-        for (const { character, score } of result.scores) {
-            const key = `${character}|${result.theme}`;
-            if (!characterAverages.has(key)) {
-                characterAverages.set(key, { theme: result.theme, scores: [] });
+            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 });
+                }
             }
-            characterAverages.get(key).scores.push(score);
-        }
-    }
-    const overallChampions = Array.from(characterAverages.entries())
-        .map(([key, data]) => {
-        const character = key.split('|')[0];
-        const avgScore = data.scores.reduce((a, b) => a + b, 0) / data.scores.length;
-        return { character, theme: data.theme, avg_score: avgScore };
-    })
-        .sort((a, b) => b.avg_score - a.avg_score)
-        .slice(0, 10);
-    // Load historical trend
-    const historicalTrend = loadHistoricalTrend(resultsDir);
-    return {
-        themes_included: allResults.map(r => r.theme),
-        last_updated: new Date().toISOString(),
-        by_role: byRole,
-        overall_champions: overallChampions,
-        historical_trend: historicalTrend,
-    };
+            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
  */
-export async function getBaselineComparison(role, resultsDir) {
-    const stats = await aggregateJobFairResults(resultsDir);
-    return stats.by_role[role]?.baseline_comparison ?? null;
+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
  */
-export async function getRoleStatistics(role, resultsDir) {
-    const stats = await aggregateJobFairResults(resultsDir);
-    return stats.by_role[role] || {
-        mean_score: 0,
-        std_dev: 0,
-        baseline_comparison: null,
-        top_performers: [],
-    };
+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)
  */
-export async function getTopPerformers(role, limit, resultsDir) {
-    const stats = await aggregateJobFairResults(resultsDir);
-    const roleStats = stats.by_role[role];
-    if (!roleStats)
-        return [];
-    return roleStats.top_performers.slice(0, limit);
+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
  */
-export async function getHistoricalTrend(role, resultsDir) {
-    const trend = loadHistoricalTrend(resultsDir);
-    if (!role)
-        return trend;
-    // Filter to role-specific points if role is specified
-    return trend.filter(point => !point.role || point.role === role);
+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
  */
-export async function saveHistoricalSnapshot(resultsDir) {
-    const stats = await aggregateJobFairResults(resultsDir);
-    // Calculate overall mean and variance from all role means
-    const roleMeans = Object.values(stats.by_role).map(r => r.mean_score);
-    const overallMean = roleMeans.length > 0
-        ? roleMeans.reduce((a, b) => a + b, 0) / roleMeans.length
-        : 0;
-    const overallVariance = calculateVariance(roleMeans, overallMean);
-    const newPoint = {
-        date: new Date().toISOString().split('T')[0],
-        mean: overallMean,
-        variance: overallVariance,
-    };
-    // Load existing history
-    const existingTrend = loadHistoricalTrend(resultsDir);
-    existingTrend.push(newPoint);
-    // Ensure aggregate directory exists
-    const aggregateDir = join(resultsDir, 'aggregate');
-    if (!existsSync(aggregateDir)) {
-        mkdirSync(aggregateDir, { recursive: true });
-    }
-    // Save updated history
-    const historyPath = getHistoryFilePath(resultsDir);
-    writeFileSync(historyPath, stringifyYaml({ snapshots: existingTrend }));
+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 */
-const DEFAULT_THEMES_DIR = join(__dirname, '../../../../pennyfarthing-dist/personas/themes');
+var DEFAULT_THEMES_DIR = (0, path_1.join)(__dirname, '../../../../pennyfarthing-dist/personas/themes');
 /**
  * Load dimensions from a theme YAML file
  */
-function loadThemeDimensions(themeName, themesDir = DEFAULT_THEMES_DIR) {
-    const themePath = join(themesDir, `${themeName}.yaml`);
-    if (!existsSync(themePath))
+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 {
-        const content = readFileSync(themePath, 'utf-8');
-        const data = parseYaml(content);
-        return data.theme?.dimensions || null;
+        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 {
+    catch (_b) {
         return null;
     }
 }
@@ -344,11 +458,11 @@ function loadThemeDimensions(themeName, themesDir = DEFAULT_THEMES_DIR) {
 function calculateSignificance(mean1, mean2, std1, std2, n1, n2) {
     if (n1 < 2 || n2 < 2)
         return 'not_significant';
-    const pooledStd = Math.sqrt(((n1 - 1) * std1 * std1 + (n2 - 1) * std2 * std2) / (n1 + n2 - 2));
+    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)
-    const effectSize = Math.abs(mean1 - mean2) / pooledStd;
+    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';
@@ -361,187 +475,216 @@ function calculateSignificance(mean1, mean2, std1, std2, n1, n2) {
  *
  * Story 7-5: AC - Job-fair aggregator groups results by dimension
  */
-export async function aggregateByDimension(dimension, resultsDir, themesDir = DEFAULT_THEMES_DIR) {
-    const latestRuns = getLatestRunPerTheme(resultsDir);
-    // Group themes by dimension value
-    const themesByValue = new Map();
-    const themeScores = new Map();
-    for (const [theme] of latestRuns) {
-        const dimensions = loadThemeDimensions(theme, themesDir);
-        if (!dimensions)
-            continue;
-        const value = dimensions[dimension];
-        if (!value)
-            continue;
-        if (!themesByValue.has(value)) {
-            themesByValue.set(value, []);
-        }
-        themesByValue.get(value).push(theme);
-    }
-    // Parse scores for each theme
-    for (const [theme, dirName] of latestRuns) {
-        const summaryPath = join(resultsDir, dirName, 'summary.yaml');
-        if (!existsSync(summaryPath))
-            continue;
-        const result = parseSummaryYaml(summaryPath, theme);
-        if (result && result.scores.length > 0) {
-            themeScores.set(theme, result.scores.map(s => ({ role: s.role, score: s.score })));
-        }
-    }
-    // Calculate stats for each dimension value
-    const values = [];
-    for (const [value, themes] of themesByValue) {
-        const roleScores = new Map();
-        const totalScores = [];
-        for (const theme of themes) {
-            const scores = themeScores.get(theme);
-            if (!scores)
-                continue;
-            for (const { role, score } of scores) {
-                if (!roleScores.has(role)) {
-                    roleScores.set(role, []);
+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, []);
                 }
-                roleScores.get(role).push(score);
-                totalScores.push(score);
+                themesByValue.get(value).push(theme);
             }
-        }
-        const byRole = {};
-        for (const [role, scores] of roleScores) {
-            const mean = scores.reduce((a, b) => a + b, 0) / scores.length;
-            const stdDev = calculateStdDev(scores, mean);
-            byRole[role] = { mean_score: mean, std_dev: stdDev, n: scores.length };
-        }
-        const overallMean = totalScores.length > 0
-            ? totalScores.reduce((a, b) => a + b, 0) / totalScores.length
-            : 0;
-        values.push({
-            value,
-            themes,
-            sample_size: totalScores.length,
-            by_role: byRole,
-            overall_mean: overallMean,
-        });
-    }
-    // Generate pairwise comparisons
-    const comparisons = [];
-    for (let i = 0; i < values.length; i++) {
-        for (let j = i + 1; j < values.length; j++) {
-            const a = values[i];
-            const b = values[j];
-            // Get all roles present in both
-            const allRoles = new Set([...Object.keys(a.by_role), ...Object.keys(b.by_role)]);
-            const roleComparisons = {};
-            for (const role of allRoles) {
-                const aRole = a.by_role[role];
-                const bRole = b.by_role[role];
-                if (aRole && bRole) {
-                    const delta = aRole.mean_score - bRole.mean_score;
-                    const significance = calculateSignificance(aRole.mean_score, bRole.mean_score, aRole.std_dev, bRole.std_dev, aRole.n, bRole.n);
-                    roleComparisons[role] = { delta, significance };
+            // 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 }); }));
                 }
             }
-            // Overall comparison
-            const overallDelta = a.overall_mean - b.overall_mean;
-            // For overall significance, use aggregated stats
-            const aScores = Object.values(a.by_role);
-            const bScores = Object.values(b.by_role);
-            const aStd = aScores.length > 0
-                ? Math.sqrt(aScores.reduce((sum, r) => sum + r.std_dev * r.std_dev, 0) / aScores.length)
-                : 0;
-            const bStd = bScores.length > 0
-                ? Math.sqrt(bScores.reduce((sum, r) => sum + r.std_dev * r.std_dev, 0) / bScores.length)
-                : 0;
-            const overallSignificance = calculateSignificance(a.overall_mean, b.overall_mean, aStd, bStd, a.sample_size, b.sample_size);
-            comparisons.push({
-                dimension,
-                value_a: a.value,
-                value_b: b.value,
-                delta: overallDelta,
-                significance: overallSignificance,
-                by_role: roleComparisons,
-            });
-        }
-    }
-    return {
-        dimension,
-        last_updated: new Date().toISOString(),
-        values,
-        comparisons,
-    };
+            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
  */
-export async function getDimensionValues(dimension, themesDir = DEFAULT_THEMES_DIR) {
-    const valueCounts = new Map();
-    if (!existsSync(themesDir))
-        return [];
-    const entries = readdirSync(themesDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.yaml'))
-            continue;
-        const themeName = entry.name.replace('.yaml', '');
-        const dimensions = loadThemeDimensions(themeName, themesDir);
-        if (dimensions && dimensions[dimension]) {
-            const value = dimensions[dimension];
-            valueCounts.set(value, (valueCounts.get(value) || 0) + 1);
-        }
-    }
-    return Array.from(valueCounts.entries())
-        .map(([value, theme_count]) => ({ value, theme_count }))
-        .sort((a, b) => b.theme_count - a.theme_count);
+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
  */
-export async function generateDifferentialReport(dimension, resultsDir, themesDir = DEFAULT_THEMES_DIR) {
-    const stats = await aggregateByDimension(dimension, resultsDir, themesDir);
-    const lines = [
-        `# Differential Report: ${dimension}`,
-        '',
-        `Generated: ${stats.last_updated}`,
-        '',
-        '## Summary by Value',
-        '',
-    ];
-    // Sort values by overall mean descending
-    const sortedValues = [...stats.values].sort((a, b) => b.overall_mean - a.overall_mean);
-    for (const v of sortedValues) {
-        lines.push(`### ${v.value}`);
-        lines.push(`- Themes: ${v.themes.length} (${v.themes.join(', ')})`);
-        lines.push(`- Sample size: ${v.sample_size}`);
-        lines.push(`- Overall mean: ${v.overall_mean.toFixed(2)}`);
-        lines.push('');
-        lines.push('| Role | Mean | Std Dev | N |');
-        lines.push('|------|------|---------|---|');
-        for (const [role, roleStats] of Object.entries(v.by_role)) {
-            lines.push(`| ${role} | ${roleStats.mean_score.toFixed(2)} | ${roleStats.std_dev.toFixed(2)} | ${roleStats.n} |`);
-        }
-        lines.push('');
-    }
-    lines.push('## Pairwise Comparisons');
-    lines.push('');
-    for (const comp of stats.comparisons) {
-        const sigLabel = comp.significance === 'significant' ? '**SIGNIFICANT**'
-            : comp.significance === 'marginal' ? '*marginal*'
-                : 'not significant';
-        const direction = comp.delta > 0 ? '>' : comp.delta < 0 ? '<' : '=';
-        lines.push(`### ${comp.value_a} ${direction} ${comp.value_b}`);
-        lines.push(`- Delta: ${comp.delta > 0 ? '+' : ''}${comp.delta.toFixed(2)} (${sigLabel})`);
-        lines.push('');
-        if (Object.keys(comp.by_role).length > 0) {
-            lines.push('| Role | Delta | Significance |');
-            lines.push('|------|-------|--------------|');
-            for (const [role, roleComp] of Object.entries(comp.by_role)) {
-                lines.push(`| ${role} | ${roleComp.delta > 0 ? '+' : ''}${roleComp.delta.toFixed(2)} | ${roleComp.significance} |`);
+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')];
             }
-            lines.push('');
-        }
-    }
-    return lines.join('\n');
+        });
+    });
 }
-//# sourceMappingURL=job-fair-aggregator.js.map