@aqa-pulse/cli 0.1.0

package/dist/history-utils.d.ts

@@ -0,0 +1,72 @@
+import type { ReporterRoot } from './dashboard-utils';
+export interface DashboardHistoryEntry {
+    id: string;
+    reportTimestamp: string | null;
+    generatedAt: string;
+    sourceFile: string;
+    comparisonKey: string | null;
+    comparisonLabel: string | null;
+    branch: string | null;
+    commit: string | null;
+    author: string | null;
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    flakyTests: number;
+    skippedTests: number;
+    timedOutTests: number;
+    interruptedTests: number;
+    passRate: number;
+    flakyRatio: number;
+    totalDurationMs: number;
+    medianDurationMs: number;
+    errorClusterCount: number;
+}
+export interface DashboardHistory {
+    schemaVersion: number;
+    updatedAt: string;
+    runs: DashboardHistoryEntry[];
+}
+export interface ArchivedRunMetadata {
+    schemaVersion: number;
+    id: string;
+    runDirectory: string;
+    dataFile: string;
+    metadataFile: string;
+    reportTimestamp: string | null;
+    generatedAt: string;
+    sourceFile: string;
+    comparisonKey: string | null;
+    comparisonLabel: string | null;
+    branch: string | null;
+    commit: string | null;
+    author: string | null;
+    kpis: {
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        flakyTests: number;
+        skippedTests: number;
+        timedOutTests: number;
+        interruptedTests: number;
+        passRate: number;
+        flakyRatio: number;
+        totalDurationMs: number;
+        medianDurationMs: number;
+        errorClusterCount: number;
+    };
+}
+export interface ArchivedRunRecord {
+    metadata: ArchivedRunMetadata;
+    data: ReporterRoot;
+}
+export declare function readDashboardHistory(historyPath: string): DashboardHistory;
+export declare function appendHistoryEntry(history: DashboardHistory, entry: DashboardHistoryEntry, limit?: number): DashboardHistory;
+export declare function writeDashboardHistory(historyPath: string, history: DashboardHistory): void;
+export declare function archiveHistoryRun(archiveRootPath: string, reportPayload: unknown, entry: DashboardHistoryEntry): ArchivedRunMetadata;
+export declare function readArchivedRunMetadata(metadataFilePath: string): ArchivedRunMetadata;
+export declare function readArchivedRunRecord(archiveRootPath: string, runDirectory: string): ArchivedRunRecord;
+export declare function findArchivedRunDirectory(archiveRootPath: string, entryId: string): string | null;
+export declare function listArchivedRunDirectories(archiveRootPath: string): string[];
+export declare function buildHistoryEntryId(reportTimestamp: string | null, sourceFile: string): string;
+export declare function createEmptyHistory(): DashboardHistory;

package/dist/history-utils.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDashboardHistory = readDashboardHistory;
+exports.appendHistoryEntry = appendHistoryEntry;
+exports.writeDashboardHistory = writeDashboardHistory;
+exports.archiveHistoryRun = archiveHistoryRun;
+exports.readArchivedRunMetadata = readArchivedRunMetadata;
+exports.readArchivedRunRecord = readArchivedRunRecord;
+exports.findArchivedRunDirectory = findArchivedRunDirectory;
+exports.listArchivedRunDirectories = listArchivedRunDirectories;
+exports.buildHistoryEntryId = buildHistoryEntryId;
+exports.createEmptyHistory = createEmptyHistory;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const DEFAULT_SCHEMA_VERSION = 2;
+const ARCHIVE_SCHEMA_VERSION = 1;
+const DEFAULT_HISTORY_LIMIT = 20;
+function readDashboardHistory(historyPath) {
+    if (!fs.existsSync(historyPath)) {
+        return createEmptyHistory();
+    }
+    try {
+        const historyText = fs.readFileSync(historyPath, 'utf8');
+        const parsedHistory = JSON.parse(historyText);
+        return {
+            schemaVersion: typeof parsedHistory.schemaVersion === 'number' ? parsedHistory.schemaVersion : DEFAULT_SCHEMA_VERSION,
+            updatedAt: typeof parsedHistory.updatedAt === 'string' ? parsedHistory.updatedAt : new Date().toISOString(),
+            runs: Array.isArray(parsedHistory.runs)
+                ? parsedHistory.runs.map(normalizeHistoryEntry)
+                : [],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Не удалось прочитать history-файл из \"${historyPath}\": ${errorMessage}`);
+    }
+}
+function normalizeHistoryEntry(run) {
+    return {
+        id: typeof run.id === 'string' ? run.id : buildHistoryEntryId(run.reportTimestamp ?? null, run.sourceFile ?? 'unknown'),
+        reportTimestamp: typeof run.reportTimestamp === 'string' ? run.reportTimestamp : null,
+        generatedAt: typeof run.generatedAt === 'string' ? run.generatedAt : new Date().toISOString(),
+        sourceFile: typeof run.sourceFile === 'string' ? run.sourceFile : 'unknown',
+        comparisonKey: typeof run.comparisonKey === 'string' ? run.comparisonKey : null,
+        comparisonLabel: typeof run.comparisonLabel === 'string' ? run.comparisonLabel : null,
+        branch: typeof run.branch === 'string' ? run.branch : null,
+        commit: typeof run.commit === 'string' ? run.commit : null,
+        author: typeof run.author === 'string' ? run.author : null,
+        totalTests: typeof run.totalTests === 'number' ? run.totalTests : 0,
+        passedTests: typeof run.passedTests === 'number' ? run.passedTests : 0,
+        failedTests: typeof run.failedTests === 'number' ? run.failedTests : 0,
+        flakyTests: typeof run.flakyTests === 'number' ? run.flakyTests : 0,
+        skippedTests: typeof run.skippedTests === 'number' ? run.skippedTests : 0,
+        timedOutTests: typeof run.timedOutTests === 'number' ? run.timedOutTests : 0,
+        interruptedTests: typeof run.interruptedTests === 'number' ? run.interruptedTests : 0,
+        passRate: typeof run.passRate === 'number' ? run.passRate : 0,
+        flakyRatio: typeof run.flakyRatio === 'number' ? run.flakyRatio : 0,
+        totalDurationMs: typeof run.totalDurationMs === 'number' ? run.totalDurationMs : 0,
+        medianDurationMs: typeof run.medianDurationMs === 'number' ? run.medianDurationMs : 0,
+        errorClusterCount: typeof run.errorClusterCount === 'number' ? run.errorClusterCount : 0,
+    };
+}
+function appendHistoryEntry(history, entry, limit = DEFAULT_HISTORY_LIMIT) {
+    const runsWithoutDuplicate = history.runs.filter((run) => run.id !== entry.id);
+    const nextRuns = [...runsWithoutDuplicate, entry]
+        .sort(compareHistoryEntries)
+        .slice(-limit);
+    return {
+        schemaVersion: history.schemaVersion,
+        updatedAt: new Date().toISOString(),
+        runs: nextRuns,
+    };
+}
+function writeDashboardHistory(historyPath, history) {
+    fs.mkdirSync(path.dirname(historyPath), { recursive: true });
+    fs.writeFileSync(historyPath, `${JSON.stringify(history, null, 2)}\n`, 'utf8');
+}
+function archiveHistoryRun(archiveRootPath, reportPayload, entry) {
+    fs.mkdirSync(archiveRootPath, { recursive: true });
+    const existingRunDirectory = findArchivedRunDirectoryById(archiveRootPath, entry.id);
+    const runDirectory = existingRunDirectory ?? buildUniqueRunDirectoryName(archiveRootPath, entry);
+    const runDirectoryPath = path.join(archiveRootPath, runDirectory);
+    const dataFileName = 'data.json';
+    const metadataFileName = 'metadata.json';
+    const dataFilePath = path.join(runDirectoryPath, dataFileName);
+    const metadataFilePath = path.join(runDirectoryPath, metadataFileName);
+    fs.mkdirSync(runDirectoryPath, { recursive: true });
+    fs.writeFileSync(dataFilePath, `${JSON.stringify(reportPayload, null, 2)}\n`, 'utf8');
+    const metadata = {
+        schemaVersion: ARCHIVE_SCHEMA_VERSION,
+        id: entry.id,
+        runDirectory,
+        dataFile: dataFileName,
+        metadataFile: metadataFileName,
+        reportTimestamp: entry.reportTimestamp,
+        generatedAt: entry.generatedAt,
+        sourceFile: entry.sourceFile,
+        comparisonKey: entry.comparisonKey,
+        comparisonLabel: entry.comparisonLabel,
+        branch: entry.branch,
+        commit: entry.commit,
+        author: entry.author,
+        kpis: {
+            totalTests: entry.totalTests,
+            passedTests: entry.passedTests,
+            failedTests: entry.failedTests,
+            flakyTests: entry.flakyTests,
+            skippedTests: entry.skippedTests,
+            timedOutTests: entry.timedOutTests,
+            interruptedTests: entry.interruptedTests,
+            passRate: entry.passRate,
+            flakyRatio: entry.flakyRatio,
+            totalDurationMs: entry.totalDurationMs,
+            medianDurationMs: entry.medianDurationMs,
+            errorClusterCount: entry.errorClusterCount,
+        },
+    };
+    fs.writeFileSync(metadataFilePath, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8');
+    return metadata;
+}
+function readArchivedRunMetadata(metadataFilePath) {
+    const metadataText = fs.readFileSync(metadataFilePath, 'utf8');
+    return JSON.parse(metadataText);
+}
+function readArchivedRunRecord(archiveRootPath, runDirectory) {
+    const runDirectoryPath = path.join(archiveRootPath, runDirectory);
+    const metadataFilePath = path.join(runDirectoryPath, 'metadata.json');
+    const dataFilePath = path.join(runDirectoryPath, 'data.json');
+    if (!fs.existsSync(metadataFilePath)) {
+        throw new Error(`Не найден metadata.json для архивного прогона: \"${runDirectoryPath}\".`);
+    }
+    if (!fs.existsSync(dataFilePath)) {
+        throw new Error(`Не найден data.json для архивного прогона: \"${runDirectoryPath}\".`);
+    }
+    const metadata = readArchivedRunMetadata(metadataFilePath);
+    const dataText = fs.readFileSync(dataFilePath, 'utf8');
+    const data = JSON.parse(dataText);
+    return {
+        metadata,
+        data,
+    };
+}
+function findArchivedRunDirectory(archiveRootPath, entryId) {
+    return findArchivedRunDirectoryById(archiveRootPath, entryId);
+}
+function listArchivedRunDirectories(archiveRootPath) {
+    if (!fs.existsSync(archiveRootPath)) {
+        return [];
+    }
+    return fs.readdirSync(archiveRootPath, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+}
+function buildHistoryEntryId(reportTimestamp, sourceFile) {
+    return `${reportTimestamp ?? 'no-timestamp'}::${sourceFile}`;
+}
+function createEmptyHistory() {
+    return {
+        schemaVersion: DEFAULT_SCHEMA_VERSION,
+        updatedAt: new Date().toISOString(),
+        runs: [],
+    };
+}
+function compareHistoryEntries(left, right) {
+    const leftTime = getEntryTime(left);
+    const rightTime = getEntryTime(right);
+    if (leftTime !== rightTime) {
+        return leftTime - rightTime;
+    }
+    return left.id.localeCompare(right.id);
+}
+function getEntryTime(entry) {
+    const reportTime = entry.reportTimestamp ? new Date(entry.reportTimestamp).getTime() : Number.NaN;
+    if (Number.isFinite(reportTime)) {
+        return reportTime;
+    }
+    const generatedTime = new Date(entry.generatedAt).getTime();
+    if (Number.isFinite(generatedTime)) {
+        return generatedTime;
+    }
+    return 0;
+}
+function findArchivedRunDirectoryById(archiveRootPath, entryId) {
+    if (!fs.existsSync(archiveRootPath)) {
+        return null;
+    }
+    for (const directoryEntry of fs.readdirSync(archiveRootPath, { withFileTypes: true })) {
+        if (!directoryEntry.isDirectory()) {
+            continue;
+        }
+        const metadataFilePath = path.join(archiveRootPath, directoryEntry.name, 'metadata.json');
+        if (!fs.existsSync(metadataFilePath)) {
+            continue;
+        }
+        try {
+            const metadataText = fs.readFileSync(metadataFilePath, 'utf8');
+            const metadata = JSON.parse(metadataText);
+            if (metadata.id === entryId) {
+                return directoryEntry.name;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function buildUniqueRunDirectoryName(archiveRootPath, entry) {
+    const baseDirectoryName = formatArchiveDirectoryName(entry.reportTimestamp ?? entry.generatedAt);
+    const preferredDirectoryPath = path.join(archiveRootPath, baseDirectoryName);
+    if (!fs.existsSync(preferredDirectoryPath)) {
+        return baseDirectoryName;
+    }
+    const hashedSuffix = (0, node_crypto_1.createHash)('sha1').update(entry.id).digest('hex').slice(0, 8);
+    return `${baseDirectoryName}--${hashedSuffix}`;
+}
+function formatArchiveDirectoryName(timestamp) {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return 'unknown-run';
+    }
+    const year = date.getFullYear();
+    const month = padNumber(date.getMonth() + 1);
+    const day = padNumber(date.getDate());
+    const hours = padNumber(date.getHours());
+    const minutes = padNumber(date.getMinutes());
+    const seconds = padNumber(date.getSeconds());
+    return `${year}-${month}-${day}--${hours}-${minutes}-${seconds}`;
+}
+function padNumber(value) {
+    return String(value).padStart(2, '0');
+}

package/dist/shared/business-assumptions.d.ts

@@ -0,0 +1,14 @@
+import type { DashboardSummary } from '../dashboard-utils';
+export interface DashboardBusinessAssumptions {
+    ciMinuteCostRub: number | null;
+    developerHourlyCostRub: number | null;
+    analysisMinutesPerUnstable: number | null;
+}
+export declare function normalizeDashboardBusinessAssumptions(assumptions: Partial<DashboardBusinessAssumptions> | null | undefined): DashboardBusinessAssumptions;
+export declare function applyBusinessAssumptionsToSummary(summary: DashboardSummary, assumptions: Partial<DashboardBusinessAssumptions> | null | undefined): DashboardSummary;
+export declare function recalculateCostOfFlakinessMetrics(baseMetrics: {
+    extraRetryMinutes: number;
+    extraRetries: number;
+    unstableRuns: number;
+    activeDays: number;
+}, assumptions: DashboardBusinessAssumptions): DashboardSummary['businessMetrics']['costOfFlakiness'];

package/dist/shared/business-assumptions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDashboardBusinessAssumptions = normalizeDashboardBusinessAssumptions;
+exports.applyBusinessAssumptionsToSummary = applyBusinessAssumptionsToSummary;
+exports.recalculateCostOfFlakinessMetrics = recalculateCostOfFlakinessMetrics;
+function normalizeDashboardBusinessAssumptions(assumptions) {
+    return {
+        ciMinuteCostRub: normalizeOptionalNonNegativeNumber(assumptions?.ciMinuteCostRub),
+        developerHourlyCostRub: normalizeOptionalNonNegativeNumber(assumptions?.developerHourlyCostRub),
+        analysisMinutesPerUnstable: normalizeOptionalNonNegativeNumber(assumptions?.analysisMinutesPerUnstable),
+    };
+}
+function applyBusinessAssumptionsToSummary(summary, assumptions) {
+    const mergedAssumptions = normalizeDashboardBusinessAssumptions({
+        ...summary.businessMetrics.costOfFlakiness.assumptions,
+        ...(assumptions ?? {}),
+    });
+    return {
+        ...summary,
+        businessMetrics: {
+            ...summary.businessMetrics,
+            costOfFlakiness: recalculateCostOfFlakinessMetrics({
+                extraRetryMinutes: summary.businessMetrics.costOfFlakiness.extraRetryMinutes,
+                extraRetries: summary.businessMetrics.costOfFlakiness.extraRetries,
+                unstableRuns: summary.businessMetrics.costOfFlakiness.unstableRuns,
+                activeDays: summary.businessMetrics.costOfFlakiness.activeDays,
+            }, mergedAssumptions),
+        },
+    };
+}
+function recalculateCostOfFlakinessMetrics(baseMetrics, assumptions) {
+    const ciCostRub = assumptions.ciMinuteCostRub === null
+        ? null
+        : roundToTwoDigits(baseMetrics.extraRetryMinutes * assumptions.ciMinuteCostRub);
+    const developerCostRub = assumptions.developerHourlyCostRub === null || assumptions.analysisMinutesPerUnstable === null
+        ? null
+        : roundToTwoDigits(baseMetrics.unstableRuns * (assumptions.analysisMinutesPerUnstable / 60) * assumptions.developerHourlyCostRub);
+    const totalRub = ciCostRub === null && developerCostRub === null
+        ? null
+        : roundToTwoDigits((ciCostRub ?? 0) + (developerCostRub ?? 0));
+    const costPerActiveDayRub = totalRub === null || baseMetrics.activeDays === 0
+        ? null
+        : roundToTwoDigits(totalRub / baseMetrics.activeDays);
+    return {
+        totalRub,
+        ciCostRub,
+        developerCostRub,
+        extraRetryMinutes: baseMetrics.extraRetryMinutes,
+        extraRetries: baseMetrics.extraRetries,
+        unstableRuns: baseMetrics.unstableRuns,
+        activeDays: baseMetrics.activeDays,
+        costPerActiveDayRub,
+        assumptions,
+    };
+}
+function normalizeOptionalNonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function roundToTwoDigits(value) {
+    return Math.round(value * 100) / 100;
+}

package/dist/shared/dashboard-helpers.d.ts

@@ -0,0 +1,63 @@
+import type { DashboardSummary } from '../dashboard-utils';
+export type DashboardStatusTone = 'neutral' | 'good' | 'warn' | 'danger';
+export type DashboardMetricTone = 'default' | 'good' | 'warn' | 'danger';
+export declare function formatCurrency(value: number | null): string;
+export declare function formatMinutes(value: number): string;
+export declare function formatNullableMinutes(value: number | null): string;
+export declare function formatDailyRatio(value: number): string;
+export declare function formatRunsPerHundred(value: number): string;
+export declare function formatScore(value: number): string;
+export declare function formatNullableDays(value: number | null): string;
+export declare function formatNullablePercent(value: number | null): string;
+export declare function formatAssumptionValue(value: number | null, unit: string): string;
+export declare function formatCommit(commit: string | null): string;
+export declare function formatStatusLabel(status: string, flaky: boolean): string;
+export declare function getStatusTone(status: string, flaky: boolean): DashboardStatusTone;
+export declare function getScoreTone(value: number): DashboardMetricTone;
+export declare function getInverseScoreTone(value: number): DashboardMetricTone;
+export declare function formatDelta(value: number | null, label: string, comparisonMode?: DashboardSummary['comparison']['mode']): string;
+export declare function formatPerformancePhaseLabel(label: string): string;
+export declare function getManagerReadinessLabel(level: DashboardSummary['managerSummary']['releaseReadiness']['level']): string;
+export declare function getManagerRiskLabel(level: DashboardSummary['managerSummary']['qualityRisk']['level']): string;
+export declare function getManagerChangeLabel(direction: DashboardSummary['managerSummary']['changes'][number]['direction']): string;
+export declare function buildFlakyHistoryInsight(summary: DashboardSummary): {
+    tone: 'default' | 'warn' | 'info';
+    title: string;
+    body: string;
+};
+export declare function getFlakyTopTestsEmptyState(summary: DashboardSummary): string;
+export declare function getCodeQualityFailureConcentration(summary: DashboardSummary): number | null;
+export declare function buildReleaseConfidenceBreakdown(summary: DashboardSummary): {
+    total: number;
+    components: Array<{
+        label: string;
+        formula: string;
+        width: string;
+        tone: string;
+    }>;
+};
+export declare function buildBusinessMetricReadiness(summary: DashboardSummary): Array<{
+    label: string;
+    status: 'ready' | 'partial' | 'pending';
+    statusLabel: string;
+    hint: string;
+}>;
+export declare function averageDashboardNumber(values: number[]): number;
+export declare function getBusinessReadinessStatusLabel(status: 'ready' | 'partial' | 'pending'): string;
+export declare function getBusinessAssumptionsState(assumptions: DashboardSummary['businessMetrics']['costOfFlakiness']['assumptions']): 'ready' | 'partial' | 'empty';
+export declare function getBusinessScenarioStatusLabel(assumptions: DashboardSummary['businessMetrics']['costOfFlakiness']['assumptions']): string;
+export declare function getBusinessScenarioStatusHint(assumptions: DashboardSummary['businessMetrics']['costOfFlakiness']['assumptions']): string;
+export declare function getBusinessImpactLevel(totalCost: number | null, costPerDay: number | null): 'high' | 'medium' | 'low' | 'unknown';
+export declare function getBusinessImpactClass(totalCost: number | null, costPerDay: number | null): string;
+export declare function getBusinessImpactLabel(totalCost: number | null, costPerDay: number | null): string;
+export declare function getBusinessDriverType(ciCost: number | null, developerCost: number | null, totalCost: number | null): 'ci' | 'development' | 'balanced' | 'missing';
+export declare function getBusinessBreakdownItemClass(ciCost: number | null, developerCost: number | null, totalCost: number | null, target: 'ci' | 'development'): string;
+export declare function getBusinessDriverSignalClass(ciCost: number | null, developerCost: number | null, totalCost: number | null, target: 'ci' | 'development'): string;
+export declare function getBusinessDriverInsightTitle(ciCost: number | null, developerCost: number | null, totalCost: number | null): string;
+export declare function getBusinessDriverInsightBody(ciCost: number | null, developerCost: number | null, totalCost: number | null): string;
+export declare function formatCostShare(value: number | null, total: number | null): string;
+export declare function formatCostShareWidth(value: number | null, total: number | null): string;
+export declare function getDashboardScoreTone(value: number): string;
+export declare function clampDashboardScore(value: number): number;
+export declare function roundToOneDigit(value: number): number;
+export declare function roundOne(value: number): number;