@aqa-pulse/cli 0.1.0

package/dist/shared/dashboard-helpers.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrency = formatCurrency;
+exports.formatMinutes = formatMinutes;
+exports.formatNullableMinutes = formatNullableMinutes;
+exports.formatDailyRatio = formatDailyRatio;
+exports.formatRunsPerHundred = formatRunsPerHundred;
+exports.formatScore = formatScore;
+exports.formatNullableDays = formatNullableDays;
+exports.formatNullablePercent = formatNullablePercent;
+exports.formatAssumptionValue = formatAssumptionValue;
+exports.formatCommit = formatCommit;
+exports.formatStatusLabel = formatStatusLabel;
+exports.getStatusTone = getStatusTone;
+exports.getScoreTone = getScoreTone;
+exports.getInverseScoreTone = getInverseScoreTone;
+exports.formatDelta = formatDelta;
+exports.formatPerformancePhaseLabel = formatPerformancePhaseLabel;
+exports.getManagerReadinessLabel = getManagerReadinessLabel;
+exports.getManagerRiskLabel = getManagerRiskLabel;
+exports.getManagerChangeLabel = getManagerChangeLabel;
+exports.buildFlakyHistoryInsight = buildFlakyHistoryInsight;
+exports.getFlakyTopTestsEmptyState = getFlakyTopTestsEmptyState;
+exports.getCodeQualityFailureConcentration = getCodeQualityFailureConcentration;
+exports.buildReleaseConfidenceBreakdown = buildReleaseConfidenceBreakdown;
+exports.buildBusinessMetricReadiness = buildBusinessMetricReadiness;
+exports.averageDashboardNumber = averageDashboardNumber;
+exports.getBusinessReadinessStatusLabel = getBusinessReadinessStatusLabel;
+exports.getBusinessAssumptionsState = getBusinessAssumptionsState;
+exports.getBusinessScenarioStatusLabel = getBusinessScenarioStatusLabel;
+exports.getBusinessScenarioStatusHint = getBusinessScenarioStatusHint;
+exports.getBusinessImpactLevel = getBusinessImpactLevel;
+exports.getBusinessImpactClass = getBusinessImpactClass;
+exports.getBusinessImpactLabel = getBusinessImpactLabel;
+exports.getBusinessDriverType = getBusinessDriverType;
+exports.getBusinessBreakdownItemClass = getBusinessBreakdownItemClass;
+exports.getBusinessDriverSignalClass = getBusinessDriverSignalClass;
+exports.getBusinessDriverInsightTitle = getBusinessDriverInsightTitle;
+exports.getBusinessDriverInsightBody = getBusinessDriverInsightBody;
+exports.formatCostShare = formatCostShare;
+exports.formatCostShareWidth = formatCostShareWidth;
+exports.getDashboardScoreTone = getDashboardScoreTone;
+exports.clampDashboardScore = clampDashboardScore;
+exports.roundToOneDigit = roundToOneDigit;
+exports.roundOne = roundOne;
+const ru_1 = require("./i18n/ru");
+const DASHBOARD_TEXT = ru_1.ru.dashboard;
+function formatCurrency(value) {
+    if (value === null) {
+        return '—';
+    }
+    return `${value.toFixed(2)} ₽`;
+}
+function formatMinutes(value) {
+    return `${value.toFixed(2)} мин`;
+}
+function formatNullableMinutes(value) {
+    return value === null ? '—' : formatMinutes(value);
+}
+function formatDailyRatio(value) {
+    return `${value.toFixed(2)} / день`;
+}
+function formatRunsPerHundred(value) {
+    return `${value.toFixed(1)} / 100 запусков`;
+}
+function formatScore(value) {
+    return `${roundOne(value)} / 100`;
+}
+function formatNullableDays(value) {
+    return value === null ? '—' : `${value.toFixed(2)} дн`;
+}
+function formatNullablePercent(value) {
+    return value === null ? '—' : `${value.toFixed(1)}%`;
+}
+function formatAssumptionValue(value, unit) {
+    if (value === null) {
+        return DASHBOARD_TEXT.states.notSet;
+    }
+    return `${value} ${unit}`;
+}
+function formatCommit(commit) {
+    return commit ? commit.slice(0, 8) : '—';
+}
+function formatStatusLabel(status, flaky) {
+    if (flaky) {
+        return DASHBOARD_TEXT.statusLabels.flaky;
+    }
+    return DASHBOARD_TEXT.statusLabels[status] ?? status;
+}
+function getStatusTone(status, flaky) {
+    if (flaky) {
+        return 'warn';
+    }
+    const normalized = status.trim().toLowerCase();
+    if (normalized === 'passed') {
+        return 'good';
+    }
+    if (normalized === 'failed' || normalized === 'timedout' || normalized === 'timed out' || normalized === 'interrupted') {
+        return 'danger';
+    }
+    return 'neutral';
+}
+function getScoreTone(value) {
+    if (value >= 80) {
+        return 'good';
+    }
+    if (value >= 60) {
+        return 'warn';
+    }
+    return 'danger';
+}
+function getInverseScoreTone(value) {
+    if (value >= 70) {
+        return 'danger';
+    }
+    if (value >= 40) {
+        return 'warn';
+    }
+    return 'good';
+}
+function formatDelta(value, label, comparisonMode = 'adjacent') {
+    if (value === null) {
+        return comparisonMode === 'comparable' ? 'Нет сопоставимого прогона для сравнения' : DASHBOARD_TEXT.states.noPreviousRun;
+    }
+    if (value === 0) {
+        return comparisonMode === 'comparable' ? 'Без изменений к сопоставимому прогону' : DASHBOARD_TEXT.states.noChanges;
+    }
+    const prefix = value > 0 ? '+' : '';
+    return comparisonMode === 'comparable'
+        ? `${prefix}${value} ${label} к сопоставимому прогону`
+        : `${prefix}${value} ${label}`;
+}
+function formatPerformancePhaseLabel(label) {
+    if (label === 'Setup') {
+        return 'Подготовка';
+    }
+    if (label === 'Teardown') {
+        return 'Завершение';
+    }
+    return 'Тесты';
+}
+function getManagerReadinessLabel(level) {
+    if (level === 'healthy') {
+        return DASHBOARD_TEXT.manager.readinessHealthy;
+    }
+    if (level === 'warning') {
+        return DASHBOARD_TEXT.manager.readinessWarning;
+    }
+    return DASHBOARD_TEXT.manager.readinessCritical;
+}
+function getManagerRiskLabel(level) {
+    if (level === 'healthy') {
+        return DASHBOARD_TEXT.manager.riskHealthy;
+    }
+    if (level === 'warning') {
+        return DASHBOARD_TEXT.manager.riskWarning;
+    }
+    return DASHBOARD_TEXT.manager.riskCritical;
+}
+function getManagerChangeLabel(direction) {
+    if (direction === 'improving') {
+        return 'Улучшается';
+    }
+    if (direction === 'regressing') {
+        return 'Деградирует';
+    }
+    return 'Без сдвига';
+}
+function buildFlakyHistoryInsight(summary) {
+    const hasHistoricalRanking = summary.flakyAnalytics.topFlakyTests.length > 0;
+    const followupLine = hasHistoricalRanking
+        ? DASHBOARD_TEXT.flakyInsights.historyReady
+        : summary.kpis.flakyTests > 0
+            ? DASHBOARD_TEXT.flakyInsights.historyMissing
+            : null;
+    return {
+        tone: hasHistoricalRanking ? 'info' : summary.kpis.flakyTests > 0 ? 'warn' : 'default',
+        title: DASHBOARD_TEXT.flakyInsights.title,
+        body: [DASHBOARD_TEXT.flakyInsights.historyLine, followupLine].filter(Boolean).join(' '),
+    };
+}
+function getFlakyTopTestsEmptyState(summary) {
+    if (summary.kpis.flakyTests > 0) {
+        return DASHBOARD_TEXT.states.flakyTestsHistoryMissing;
+    }
+    return DASHBOARD_TEXT.states.flakyTestsEmpty;
+}
+function getCodeQualityFailureConcentration(summary) {
+    const unsuccessfulTests = summary.kpis.failedTests + summary.kpis.timedOutTests + summary.kpis.interruptedTests;
+    if (unsuccessfulTests === 0) {
+        return null;
+    }
+    const hotspotFailures = summary.topProblematicTests.filter((test) => test.status === 'failed' || test.status === 'timedout' || test.status === 'interrupted').length;
+    return roundOne((hotspotFailures / unsuccessfulTests) * 100);
+}
+function buildReleaseConfidenceBreakdown(summary) {
+    const passRateValue = clampDashboardScore(summary.kpis.passRate);
+    const inverseFlakyValue = clampDashboardScore(100 - summary.kpis.flakyRatio);
+    const errorHealthValue = summary.kpis.totalTests === 0
+        ? 100
+        : clampDashboardScore(100 - ((summary.errorClusters.length / summary.kpis.totalTests) * 100));
+    const recentRuns = summary.history.recentRuns.slice(-5);
+    const historyConsistencyValue = recentRuns.length > 0
+        ? clampDashboardScore(averageDashboardNumber(recentRuns.map((run) => run.passRate - run.flakyRatio)))
+        : clampDashboardScore(summary.kpis.passRate - summary.kpis.flakyRatio);
+    const componentDefinitions = [
+        {
+            label: DASHBOARD_TEXT.business.releaseConfidencePassRate,
+            rawValue: passRateValue,
+            weight: 0.4,
+        },
+        {
+            label: DASHBOARD_TEXT.business.releaseConfidenceFlakyRatio,
+            rawValue: inverseFlakyValue,
+            weight: 0.3,
+        },
+        {
+            label: DASHBOARD_TEXT.business.releaseConfidenceErrorHealth,
+            rawValue: errorHealthValue,
+            weight: 0.15,
+        },
+        {
+            label: DASHBOARD_TEXT.business.releaseConfidenceHistoryConsistency,
+            rawValue: historyConsistencyValue,
+            weight: 0.15,
+        },
+    ];
+    return {
+        total: roundOne(componentDefinitions.reduce((total, component) => total + (component.rawValue * component.weight), 0)),
+        components: componentDefinitions.map((component) => ({
+            label: component.label,
+            formula: `${roundOne(component.rawValue)} × ${component.weight} = ${roundOne(component.rawValue * component.weight)}`,
+            width: `${roundOne(component.rawValue)}%`,
+            tone: getDashboardScoreTone(component.rawValue),
+        })),
+    };
+}
+function buildBusinessMetricReadiness(summary) {
+    const costAssumptionsState = getBusinessAssumptionsState(summary.businessMetrics.costOfFlakiness.assumptions);
+    const costStatus = costAssumptionsState === 'empty' ? 'pending' : costAssumptionsState;
+    const timeToFixStatus = summary.businessMetrics.timeToFixFlaky.medianDays === null ? 'pending' : 'ready';
+    return [
+        {
+            label: DASHBOARD_TEXT.metrics.timeToDetect,
+            status: 'pending',
+            statusLabel: DASHBOARD_TEXT.business.readinessPending,
+            hint: DASHBOARD_TEXT.business.readinessTimeToDetectHint,
+        },
+        {
+            label: DASHBOARD_TEXT.metrics.timeToFixFlaky,
+            status: timeToFixStatus,
+            statusLabel: getBusinessReadinessStatusLabel(timeToFixStatus),
+            hint: DASHBOARD_TEXT.business.readinessTimeToFixHint,
+        },
+        {
+            label: DASHBOARD_TEXT.metrics.costOfFlakiness,
+            status: costStatus,
+            statusLabel: getBusinessReadinessStatusLabel(costStatus),
+            hint: DASHBOARD_TEXT.business.readinessCostHint,
+        },
+        {
+            label: DASHBOARD_TEXT.metrics.developerFriction,
+            status: 'ready',
+            statusLabel: DASHBOARD_TEXT.business.readinessReady,
+            hint: DASHBOARD_TEXT.business.readinessDeveloperFrictionHint,
+        },
+        {
+            label: DASHBOARD_TEXT.metrics.releaseConfidenceScore,
+            status: 'ready',
+            statusLabel: DASHBOARD_TEXT.business.readinessReady,
+            hint: DASHBOARD_TEXT.business.readinessReleaseConfidenceHint,
+        },
+        {
+            label: DASHBOARD_TEXT.metrics.automationRoi,
+            status: 'pending',
+            statusLabel: DASHBOARD_TEXT.business.readinessPending,
+            hint: DASHBOARD_TEXT.business.readinessAutomationRoiHint,
+        },
+    ];
+}
+function averageDashboardNumber(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((total, value) => total + value, 0) / values.length;
+}
+function getBusinessReadinessStatusLabel(status) {
+    if (status === 'ready') {
+        return DASHBOARD_TEXT.business.readinessReady;
+    }
+    if (status === 'partial') {
+        return DASHBOARD_TEXT.business.readinessPartial;
+    }
+    return DASHBOARD_TEXT.business.readinessPending;
+}
+function getBusinessAssumptionsState(assumptions) {
+    const isCiConfigured = assumptions.ciMinuteCostRub !== null;
+    const isDeveloperConfigured = assumptions.developerHourlyCostRub !== null && assumptions.analysisMinutesPerUnstable !== null;
+    const hasAnyValue = isCiConfigured || assumptions.developerHourlyCostRub !== null || assumptions.analysisMinutesPerUnstable !== null;
+    if (isCiConfigured && isDeveloperConfigured) {
+        return 'ready';
+    }
+    if (hasAnyValue) {
+        return 'partial';
+    }
+    return 'empty';
+}
+function getBusinessScenarioStatusLabel(assumptions) {
+    const state = getBusinessAssumptionsState(assumptions);
+    if (state === 'ready') {
+        return DASHBOARD_TEXT.business.scenarioStatusReady;
+    }
+    if (state === 'partial') {
+        return DASHBOARD_TEXT.business.scenarioStatusPartial;
+    }
+    return DASHBOARD_TEXT.business.scenarioStatusEmpty;
+}
+function getBusinessScenarioStatusHint(assumptions) {
+    const state = getBusinessAssumptionsState(assumptions);
+    if (state === 'ready') {
+        return DASHBOARD_TEXT.business.scenarioStatusReadyHint;
+    }
+    if (state === 'partial') {
+        return DASHBOARD_TEXT.business.scenarioStatusPartialHint;
+    }
+    return DASHBOARD_TEXT.business.scenarioStatusEmptyHint;
+}
+function getBusinessImpactLevel(totalCost, costPerDay) {
+    if (totalCost === null) {
+        return 'unknown';
+    }
+    if (totalCost >= 50000 || (costPerDay !== null && costPerDay >= 10000)) {
+        return 'high';
+    }
+    if (totalCost >= 15000 || (costPerDay !== null && costPerDay >= 3000)) {
+        return 'medium';
+    }
+    return 'low';
+}
+function getBusinessImpactClass(totalCost, costPerDay) {
+    return `impact-${getBusinessImpactLevel(totalCost, costPerDay)}`;
+}
+function getBusinessImpactLabel(totalCost, costPerDay) {
+    const impactLevel = getBusinessImpactLevel(totalCost, costPerDay);
+    if (impactLevel === 'high') {
+        return DASHBOARD_TEXT.business.impactHigh;
+    }
+    if (impactLevel === 'medium') {
+        return DASHBOARD_TEXT.business.impactMedium;
+    }
+    if (impactLevel === 'low') {
+        return DASHBOARD_TEXT.business.impactLow;
+    }
+    return DASHBOARD_TEXT.business.impactUnknown;
+}
+function getBusinessDriverType(ciCost, developerCost, totalCost) {
+    if (totalCost === null || totalCost <= 0) {
+        return 'missing';
+    }
+    const normalizedCiCost = ciCost ?? 0;
+    const normalizedDeveloperCost = developerCost ?? 0;
+    const delta = Math.abs(normalizedCiCost - normalizedDeveloperCost);
+    if (delta <= totalCost * 0.15) {
+        return 'balanced';
+    }
+    return normalizedCiCost > normalizedDeveloperCost ? 'ci' : 'development';
+}
+function getBusinessBreakdownItemClass(ciCost, developerCost, totalCost, target) {
+    return getBusinessDriverType(ciCost, developerCost, totalCost) === target ? 'is-dominant' : '';
+}
+function getBusinessDriverSignalClass(ciCost, developerCost, totalCost, target) {
+    return getBusinessDriverType(ciCost, developerCost, totalCost) === target ? 'is-dominant' : '';
+}
+function getBusinessDriverInsightTitle(ciCost, developerCost, totalCost) {
+    const driverType = getBusinessDriverType(ciCost, developerCost, totalCost);
+    if (driverType === 'ci') {
+        return DASHBOARD_TEXT.business.topDriverCiTitle;
+    }
+    if (driverType === 'development') {
+        return DASHBOARD_TEXT.business.topDriverDevelopmentTitle;
+    }
+    if (driverType === 'balanced') {
+        return DASHBOARD_TEXT.business.topDriverBalancedTitle;
+    }
+    return DASHBOARD_TEXT.business.topDriverMissingTitle;
+}
+function getBusinessDriverInsightBody(ciCost, developerCost, totalCost) {
+    const driverType = getBusinessDriverType(ciCost, developerCost, totalCost);
+    if (driverType === 'ci') {
+        return DASHBOARD_TEXT.business.topDriverCiBody;
+    }
+    if (driverType === 'development') {
+        return DASHBOARD_TEXT.business.topDriverDevelopmentBody;
+    }
+    if (driverType === 'balanced') {
+        return DASHBOARD_TEXT.business.topDriverBalancedBody;
+    }
+    return DASHBOARD_TEXT.business.topDriverMissingBody;
+}
+function formatCostShare(value, total) {
+    if (value === null || total === null || total <= 0) {
+        return '—';
+    }
+    return `${((value / total) * 100).toFixed(1)}%`;
+}
+function formatCostShareWidth(value, total) {
+    if (value === null || total === null || total <= 0) {
+        return '0%';
+    }
+    return `${Math.max(0, Math.min(100, (value / total) * 100)).toFixed(1)}%`;
+}
+function getDashboardScoreTone(value) {
+    if (value >= 80) {
+        return '';
+    }
+    if (value >= 60) {
+        return 'warning';
+    }
+    return 'danger';
+}
+function clampDashboardScore(value) {
+    return Math.min(Math.max(value, 0), 100);
+}
+function roundToOneDigit(value) {
+    return roundOne(value);
+}
+function roundOne(value) {
+    return Math.round(value * 10) / 10;
+}

package/dist/shared/dashboard-metric-info.d.ts

@@ -0,0 +1,61 @@
+export declare const DASHBOARD_METRIC_DESCRIPTIONS: {
+    readonly releaseConfidenceBreakdownTitle: "Сводный прокси-сигнал риска релиза на базе доступной истории: помогает оценить, насколько текущему тестовому сигналу можно доверять перед решением о релизе.";
+    readonly managerSummary: "Насколько надёжен текущий тестовый сигнал для решения о релизе, насколько высок риск качества и насколько нестабильность уже влияет на скорость поставки.";
+    readonly releaseReadiness: "Позитивный сводный сигнал: показывает, насколько текущий pass rate, flaky ratio и история прогонов дают опору для решения о релизе.";
+    readonly qualityRisk: "Сводная оценка риска дефектов и нестабильности: чем выше показатель, тем больше вероятность, что текущее качество требует дополнительной проверки.";
+    readonly deliveryRisk: "Сводный сигнал показывает, насколько текущая нестабильность и блокеры влияют на скорость поставки изменений.";
+    readonly currentRunTests: "Полный список тестов текущего прогона с разбиением по статусам и отдельным flaky-срезом.";
+    readonly signalCoverage: "Показывает, какая доля сигналов уже доступна для risk ranking, root-cause анализа и heuristic/AI слоя.";
+    readonly modelReadiness: "Секция собирает ключевые входные сигналы, по которым видно, насколько текущий ingestion готов к heuristic/AI сценариям.";
+    readonly passRate: "Доля тестов, завершившихся статусом passed в текущем прогоне.";
+    readonly failedTests: "Количество тестов с финальным неуспешным статусом: failed, timed out или interrupted.";
+    readonly flakyTests: "Количество flaky-тестов именно в текущем прогоне: тест требовал ретраев или менял статус между попытками.";
+    readonly runDuration: "Общая длительность текущего прогона по данным Playwright.";
+    readonly medianDuration: "Медианная длительность одного теста в текущем прогоне.";
+    readonly errorClusters: "Группы одинаковых или похожих сообщений об ошибках для быстрого анализа.";
+    readonly environment: "Окружение запуска: ОС, версии Playwright и Node.js.";
+    readonly latestVsPrevious: "Сравнение текущего прогона с предыдущим доступным прогоном в истории.";
+    readonly passRateTrend: "История изменения доли успешных тестов по архивным прогонам.";
+    readonly statusDistribution: "Распределение финальных статусов тестов в текущем прогоне.";
+    readonly recentRuns: "Последние архивные прогоны, попавшие в историю AQA Pulse.";
+    readonly notes: "Служебные заметки и выводы, сформированные во время построения отчёта.";
+    readonly durationTrend: "Тренд общей длительности прогонов по истории.";
+    readonly p95Duration: "95-й перцентиль длительности тестов в текущем срезе. Помогает видеть типичную верхнюю границу без влияния единичных экстремумов.";
+    readonly p99Duration: "99-й перцентиль длительности тестов. Показывает хвост самых тяжёлых тестов и помогает искать редкие, но дорогие задержки.";
+    readonly topSlowestTests: "Самые медленные тесты текущего среза, требующие оптимизации.";
+    readonly phaseBreakdown: "Оценка распределения времени между подготовкой, исполнением тестовых шагов и завершением. Фазы определяются по шагам и служебным названиям в отчёте Playwright, а доли нормализуются по сумме фазового времени.";
+    readonly suiteDuration: "Какие наборы тестов суммарно занимают больше всего времени в текущем срезе. Наборы группируются по префиксу title или по имени spec-файла, а доли считаются внутри общего времени всех наборов.";
+    readonly durationPerBrowser: "Сколько времени занимают браузеры текущего среза. Если в отчёте есть поле browser, AQA Pulse использует его как есть. Если поля нет, по умолчанию используется Chrome. Доли считаются внутри общего времени по всем браузерам/проектам.";
+    readonly flakyTrend: "Тренд количества нестабильных тестов по архивным прогонам.";
+    readonly clusterList: "Распределение падений по кластерам ошибок и примеры тестов.";
+    readonly problemHotspots: "Количество сценариев, которые прямо сейчас формируют основной backlog по качеству тестового кода и требуют первоочередного разбора.";
+    readonly brittlenessProxy: "Прокси-хрупкость тестового набора: опирается на средний исторический flaky score и показывает, насколько часто набор ведёт себя нестабильно по истории.";
+    readonly failureConcentration: "Показывает, какая доля текущих неуспешных тестов сосредоточена в небольшом наборе проблемных сценариев. Чем выше доля, тем сильнее сигнал локализован в нескольких тестах.";
+    readonly retryDensity: "Плотность лишних повторов по истории: сколько rerun-нагрузки приходится на 100 наблюдавшихся запусков.";
+    readonly testSmellScore: "Композитный score по source-анализу Playwright spec-файлов. Учитывает жёсткие паузы, direct locator usage, отсутствие POM-сигнала, слабую step-структуру и хрупкие селекторы.";
+    readonly pomCompliance: "Доля тестов, где spec-файл выглядит как consumer page object / screen-model слоя, а не хранит основную locator-логику прямо внутри теста.";
+    readonly assertionDensity: "Среднее число expect() на тест по доступным исходникам. Помогает увидеть сценарии, которые делают много действий, но слабо проверяют результат.";
+    readonly waitStrategyScore: "Баланс между web-first/assert-based ожиданиями и жёсткими ожиданиями вроде waitForTimeout. Чем выше score, тем устойчивее стратегия ожиданий.";
+    readonly stepGranularity: "Среднее число test.step на тест. Метрика показывает, насколько сценарии разбиты на читаемые этапы для отчётов и диагностики.";
+    readonly isolationScore: "Эвристика независимости тестов по исходникам: penalizes shared mutable state, heavy beforeAll и serial execution hints.";
+    readonly selectorStability: "Оценка устойчивости selector-подхода: role/label/testid дают лучший score, длинные CSS-цепочки и XPath — худший.";
+    readonly sourceCoverage: "Какая доля тестов текущего среза была реально сопоставлена с доступными spec-файлами и попала под source-анализ.";
+    readonly problematicTests: "Тесты с наибольшей долей падений и высокой вероятностью повторных инцидентов.";
+    readonly failureRate: "Доля неуспешных попыток от общего числа запусков теста.";
+    readonly topFlakyTests: "Приоритетный список для разбора по архивной истории AQA Pulse: приоритизация строится по flaky-индексу, а не только по текущему запуску. В таблице показывается топ-10 тестов, а расчёт опирается на последние 20 архивных прогонов.";
+    readonly flakyScore: "Композитный индекс нестабильности теста по истории прогонов.";
+    readonly mtbf: "Среднее время между нестабильными инцидентами теста.";
+    readonly unstableRuns: "Количество архивных прогонов, в которых тест был нестабильным.";
+    readonly codeQuality: "Плейсхолдер для будущих метрик качества тестового кода и соблюдения практик Playwright.";
+    readonly timeToDetect: "Время от падения до уведомления команды. В MVP-плане метрика требует интеграции с каналом алертов, поэтому без него показывается как ожидающая настройки.";
+    readonly timeToFixFlaky: "Медианное время от первого нестабильного инцидента до первого стабильного восстановления по доступной истории.";
+    readonly ciWasteTime: "Суммарное время, потерянное на лишние ретраи и повторные прогоны в CI по доступной истории.";
+    readonly costOfFlakiness: "Оценка потерь от нестабильных тестов на основе стоимости минуты CI и стоимости часа разработки.";
+    readonly investigationCost: "Оценка стоимости инженерного разбора нестабильных прогонов на основе assumptions по времени анализа и стоимости часа разработки.";
+    readonly developerFriction: "Прокси-нагрузка на команду из-за ретраев, повторных запусков и разбора нестабильных инцидентов.";
+    readonly releaseConfidenceScore: "Сводный прокси-сигнал риска релиза на базе доступной истории: помогает оценить, насколько текущему тестовому сигналу можно доверять перед решением о релизе.";
+    readonly automationRoi: "Возврат инвестиций в автоматизацию. По формуле из MVP-плана требует данных о сэкономленных ручных часах и стоимости поддержки.";
+    readonly configAssumptions: "Параметры сценарного пересчёта стоимости нестабильности.";
+    readonly teamMetrics: "Плейсхолдер для будущих командных метрик по ownership и здоровью автотестов.";
+    readonly aiMetrics: "Плейсхолдер для будущих AI/ML-метрик и прогнозных моделей.";
+};

package/dist/shared/dashboard-metric-info.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DASHBOARD_METRIC_DESCRIPTIONS = void 0;
+const ru_1 = require("./i18n/ru");
+exports.DASHBOARD_METRIC_DESCRIPTIONS = {
+    ...ru_1.ru.dashboard.tooltips,
+    releaseConfidenceBreakdownTitle: ru_1.ru.dashboard.tooltips.releaseConfidenceScore,
+    managerSummary: ru_1.ru.dashboard.manager.summaryDescription,
+    releaseReadiness: 'Позитивный сводный сигнал: показывает, насколько текущий pass rate, flaky ratio и история прогонов дают опору для решения о релизе.',
+    qualityRisk: 'Сводная оценка риска дефектов и нестабильности: чем выше показатель, тем больше вероятность, что текущее качество требует дополнительной проверки.',
+    deliveryRisk: 'Сводный сигнал показывает, насколько текущая нестабильность и блокеры влияют на скорость поставки изменений.',
+    currentRunTests: ru_1.ru.dashboard.testsBrowser.description,
+    signalCoverage: 'Показывает, какая доля сигналов уже доступна для risk ranking, root-cause анализа и heuristic/AI слоя.',
+    modelReadiness: 'Секция собирает ключевые входные сигналы, по которым видно, насколько текущий ingestion готов к heuristic/AI сценариям.',
+};

package/dist/shared/error-utils.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessage(error: unknown): string;

package/dist/shared/error-utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessage = getErrorMessage;
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/shared/formatting.d.ts

@@ -0,0 +1,3 @@
+export declare function formatPercent(value: number): string;
+export declare function formatDuration(durationMs: number): string;
+export declare function formatDate(timestamp: string | null): string;

package/dist/shared/formatting.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPercent = formatPercent;
+exports.formatDuration = formatDuration;
+exports.formatDate = formatDate;
+function formatPercent(value) {
+    return `${value.toFixed(1)}%`;
+}
+function formatDuration(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs <= 0) {
+        return '0s';
+    }
+    const totalSeconds = Math.round(durationMs / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0 || hours > 0) {
+        parts.push(`${minutes}m`);
+    }
+    parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+function formatDate(timestamp) {
+    if (!timestamp) {
+        return '—';
+    }
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return timestamp;
+    }
+    return new Intl.DateTimeFormat('ru-RU', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    }).format(date);
+}