mirror of
https://github.com/Matysh/houseplan-card
synced 2026-10-01 20:29:00 +00:00
feat(process): process metrics by track — segments, returns, ship findings, job minutes (#728)
The weekly report could not say whether the tracks of #695/#696 paid off: it read only the first S4/S5/S7/S8 placements of closed issues, no track, no waiting, no reason for a return, and the CLI never passed jobs, so the "Job-минуты" line never printed. The owner decides on these numbers, so the definitions are spelled out in the report headers and anything unknown is printed as such. scripts/process-metrics.mjs (pure functions over the snapshot): - K1 trackAt/trackPath: track at a moment from the labels set before it, resolved by process-track.mjs (labelTrack) — one rule with the pipeline; infra = no class A file in the issue's commits (Release: commits aside). The issue's track is the one at its first S8-merged. - K2 issueSegments: queue/spec/work/review/rework/blocked from the first status label to the first S8, summing to lead; blocked is taken out of the segment under it; S7 over S7 is neither a return nor a new segment. - K3 returnSignal/returnReason: S7 -> S6/S3 and S4 -> S3 returns, reason from the last comment with a sign between the review placement and the return. merge and the "not run" family come from PIPELINE_EVENTS, the verdicts from verdictDeclaration with the issue's own document; the two continuations have no pipeline constant, so NOT_RUN_VALIDATE_RE and NOT_RUN_CONFLICT_RE are exported copies held by a contract test on the _process.yml templates. Anything else is unknown; hp:route (#726) gives reclassify/owner-question when present. - K4 shipFindings: High/Medium/Low of SHIP-REVIEW-*.md (docs/reviews and legacy/reviews) by the anchor block, summed per issue; the track table counts each document once. - K5 stageMinutes: jobs of process and Validate runs (skipped runs aside, at most 600, "усечено: N из M" beyond), stages by job name, per track at run time, Validate per event; unavailable jobs are "нет данных", not 0. jobMinutes gets the same data and prints again. - K6 tokenUsage: "Токены: нет данных (…)" until the pipeline records usage (issue F); the hp:usage line format is provisional. - K7 compareCohorts: issues with the first S8 within 28 days before and after 2026-09-28 (--compare, --compare-days), cohort = track x volume bucket (<=30/31-200/201-1000/>1000 lines of Issue-trailer commits without Release:, class D and docs/reviews/**); n < 3 on a side is "мало данных". - fetchSnapshot: issues state=all since the earliest window (the old selection is still "closed in the window"), timelines up to 10 pages (beyond: "таймлайн усечён"), jobs, ship and usage review docs, git log --numstat of origin/dev. _process-metrics.yml: full history (fetch-depth: 0) for K1/K7 and a 30 minute ceiling. The thin process-metrics.yml is unchanged. PROCESS.md §5 points at the report. Old sections and their tests are unchanged. Issue: #728 User-Visible: no Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018qZfe7YS4rqEMKoVeS3GKd
This commit is contained in:
Claude
@@ -5,6 +5,12 @@ name: "Метрики процесса · тело (#623)"
|
||||
# идёт в step summary и артефакт; в issue и репозиторий ничего не пишется.
|
||||
# Цифры аудита 22.09 (1,57 раунда код-ревью, S7 ≈ 36 мин/раунд, 226 Validate
|
||||
# за неделю) были собраны руками за час — теперь они стоят один запуск.
|
||||
#
|
||||
# #728: эффект процесса по трекам — отрезки, возвраты с причинами, находки
|
||||
# ship, job-минуты по стадиям и сравнение до/после 28.09. Прогон дороже:
|
||||
# jobs до 600 прогонов и таймлайны задач окна сравнения (≈ 600–800 запросов),
|
||||
# поэтому потолок 30 минут; трек инфраструктуры и объём задачи читаются из
|
||||
# истории git — нужна полная история dev.
|
||||
|
||||
on:
|
||||
# #623: тело вызывается тонким файлом `process-metrics.yml` из ветки по умолчанию
|
||||
@@ -26,14 +32,15 @@ jobs:
|
||||
metrics:
|
||||
name: "Снимок недели: issue, раунды, прогоны"
|
||||
runs-on: ubuntu-24.04
|
||||
timeout-minutes: 15
|
||||
timeout-minutes: 30
|
||||
steps:
|
||||
# Код — из dev, как у reconcile: расписание читается из main, а исполняется
|
||||
# версия, которую проверил CI.
|
||||
# версия, которую проверил CI. Полная история (#728): коммиты задачи по
|
||||
# трейлеру `Issue: #NN` дают признак инфраструктуры и объём для сравнения.
|
||||
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
|
||||
with:
|
||||
ref: dev
|
||||
fetch-depth: 1
|
||||
fetch-depth: 0
|
||||
persist-credentials: false
|
||||
- uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7
|
||||
with:
|
||||
|
||||
@@ -562,6 +562,8 @@ patch-id кандидата слияния: вердикт к работе за
|
||||
короткий (`trivial`) — 41 мин и 5 событий. Трек определялся формальными
|
||||
критериями, и у владельца не было метки, чтобы задать его самому.
|
||||
|
||||
Эффект треков меряет еженедельный отчёт `process-metrics.yml` (#728).
|
||||
|
||||
**Трек задаёт метка `track:ship`, `track:show` или `track:ask`. Метка владельца
|
||||
главнее критериев:** критерии ниже — подсказка аналитика, а не приговор.
|
||||
|
||||
|
||||
+834
-30
@@ -10,11 +10,27 @@
|
||||
// stdout/файл; куда его класть, решает workflow (`process-metrics.yml`:
|
||||
// step summary + artifact, опционально комментарий в issue-журнал).
|
||||
//
|
||||
//
|
||||
// #728: эффект процесса по трекам — трек на момент события, отрезки времени
|
||||
// (работа, ожидание, переделка), возвраты с причинами, находки пакетного ревью
|
||||
// ship, job-минуты по стадиям, токены и сравнение сопоставимых задач до и после
|
||||
// перехода на треки. Определения — в ТЗ #728 и в заголовках разделов отчёта.
|
||||
// Отчёт только читает: признаки конвейера импортируются, а не копируются, где
|
||||
// у конвейера есть константа; где её нет (`validate-red`/`conflict`), копию
|
||||
// текста держит контрактный тест на шаблонах `_process.yml`.
|
||||
//
|
||||
// node scripts/process-metrics.mjs --repo=<owner/repo> --days=7 [--until=ISO] [--output=path.md] [--json=path.json]
|
||||
// [--compare=2026-09-28] [--compare-days=28]
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { mkdirSync, writeFileSync } from 'node:fs';
|
||||
import { dirname } from 'node:path';
|
||||
import { isMainModule } from './spawn-portable.mjs';
|
||||
import { classify } from './change-classes.mjs';
|
||||
import { labelTrack, parseNumstat } from './process-track.mjs';
|
||||
import { issueTrailers } from './release-membership.mjs';
|
||||
import { verdictDeclaration } from './review-doc-guard.mjs';
|
||||
import { parseAnchorBlock } from './ship-review.mjs';
|
||||
import { PIPELINE_EVENTS } from './wait-verdict.mjs';
|
||||
|
||||
export const STATUS_LABELS = ['S1-new', 'S2-analysis', 'S3-spec', 'S4-spec-review', 'S5-ready', 'S6-in-progress', 'S7-code-review', 'S8-merged'];
|
||||
const PROCESS_RUN = /^process #(\d+) · (S4-spec-review|S7-code-review)(?: ·|$)/;
|
||||
@@ -160,8 +176,577 @@ export function jobMinutes(jobsByRun = new Map()) {
|
||||
return { totalMinutes: minutes(total), mutantMinutes: minutes(mutants), mutantShare: total ? Math.round((mutants / total) * 100) : null };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// #728: эффект процесса по трекам.
|
||||
|
||||
const DAY_MS = 86_400_000;
|
||||
/** Решение владельца о треках (PROCESS.md §5, #695): граница сравнения «до и после». */
|
||||
export const TRACKS_CUTOVER = '2026-09-28';
|
||||
export const COMPARE_DAYS = 28;
|
||||
/** Минимальная когорта сравнения: меньше — «мало данных», разницы нет. */
|
||||
export const MIN_COHORT = 3;
|
||||
/** Jobs запрашиваются не больше чем для стольких прогонов окна. */
|
||||
export const JOBS_RUN_CAP = 600;
|
||||
/** Таймлайн issue читается не дальше стольких страниц по 100 событий. */
|
||||
export const TIMELINE_PAGE_CAP = 10;
|
||||
export const TRACKS = ['ship', 'show', 'ask'];
|
||||
export const SEGMENTS = ['queue', 'spec', 'work', 'review', 'rework', 'blocked'];
|
||||
export const RETURN_REASONS = ['verdict-yellow', 'verdict-red', 'validate-red', 'conflict', 'merge', 'reclassify', 'owner-question', 'unknown'];
|
||||
export const PIPELINE_STAGES = ['guard', 'prepare', 'model', 'integrate'];
|
||||
export const VOLUME_BUCKETS = ['≤30', '31–200', '201–1000', '>1000'];
|
||||
export const VALIDATE_WORKFLOW = 'Проверка (CI)';
|
||||
export const TOKENS_NO_DATA = 'Токены: нет данных (конвейер не записывает расход модели)';
|
||||
|
||||
/**
|
||||
* Причины `validate-red` и `conflict` (К3). У конвейера нет для них отдельной
|
||||
* константы: оба комментария `_process.yml` («Validate красный — вернуть
|
||||
* автору без ревью» и «Конфликт с dev — вернуть автору без ревью») идут под
|
||||
* одним префиксом `PIPELINE_EVENTS` с `kind: 'conflict'`. Причину даёт
|
||||
* продолжение первой строки. Это копия текста шаблонов, а не импорт: от
|
||||
* расхождения её держит контрактный тест на самих шаблонах (AC3 #728).
|
||||
*/
|
||||
export const NOT_RUN_VALIDATE_RE = /^\*\*Ревью не запускалось:\*\* Validate(?: с мутантами)? на материале /m;
|
||||
export const NOT_RUN_CONFLICT_RE = /^\*\*Ревью не запускалось:\*\* ветка \S+ не ребейзится на /m;
|
||||
/** Маршрут вердикта show (#726): машинная строка комментария конвейера. */
|
||||
export const ROUTE_RE = /<!--\s*hp:route\s+(reclassify|owner-question)\b[^>]*-->/;
|
||||
/**
|
||||
* Машинная строка расхода модели в документе ревью — её запишет конвейер
|
||||
* (issue F, К6 #728): `<!-- hp:usage input_tokens=N output_tokens=N … -->`.
|
||||
* Формат предварительный: пока строки нет нигде, отчёт печатает «нет данных».
|
||||
*/
|
||||
export const USAGE_LINE_RE = /<!--\s*hp:usage\s+([^>]*?)\s*-->/g;
|
||||
|
||||
/** Признак конвейера по `kind`: переименование в `wait-verdict.mjs` ломает загрузку, а не молча даёт `unknown`. */
|
||||
function pipelineEvent(kind) {
|
||||
const event = PIPELINE_EVENTS.find((entry) => entry.kind === kind);
|
||||
if (!event) throw new Error(`process-metrics: в PIPELINE_EVENTS (wait-verdict.mjs) нет kind '${kind}'`);
|
||||
return event.re;
|
||||
}
|
||||
/** Общий префикс «Ревью не запускалось»: семейство, не причина. */
|
||||
const NOT_RUN_RE = pipelineEvent('conflict');
|
||||
/** Неудачное слияние после ревью: «Слияние отменено», «Код-ревью зелёное — вердикт выше в силе». */
|
||||
const MERGE_RES = [pipelineEvent('stale'), pipelineEvent('merge-conflict')];
|
||||
|
||||
const toMs = (value) => (typeof value === 'number' ? value : at(value));
|
||||
|
||||
/** События меток таймлайна в порядке времени (при равном времени — в порядке таймлайна). */
|
||||
function labelEvents(events = []) {
|
||||
return (events || [])
|
||||
.map((event, index) => ({ event, index }))
|
||||
.filter(({ event }) => (event?.event === 'labeled' || event?.event === 'unlabeled') && event.label?.name)
|
||||
.map(({ event, index }) => ({ type: event.event, label: event.label.name, at: at(event.created_at), index }))
|
||||
.filter((event) => Number.isFinite(event.at))
|
||||
.sort((a, b) => a.at - b.at || a.index - b.index);
|
||||
}
|
||||
|
||||
/** Комментарии таймлайна (`commented`) в порядке времени. */
|
||||
function commentEvents(events = []) {
|
||||
return (events || [])
|
||||
.map((event, index) => ({ event, index }))
|
||||
.filter(({ event }) => event?.event === 'commented')
|
||||
.map(({ event, index }) => ({ body: String(event.body ?? ''), at: at(event.created_at), index }))
|
||||
.filter((comment) => Number.isFinite(comment.at))
|
||||
.sort((a, b) => a.at - b.at || a.index - b.index);
|
||||
}
|
||||
|
||||
/**
|
||||
* Метки на задаче в момент `t`: все `labeled`/`unlabeled` строго до `t`
|
||||
* (`inclusive` — включая события в сам момент `t`).
|
||||
*/
|
||||
export function labelsAt(events, t, { inclusive = false } = {}) {
|
||||
const moment = toMs(t);
|
||||
const labels = new Set();
|
||||
for (const event of labelEvents(events)) {
|
||||
if (inclusive ? event.at > moment : event.at >= moment) break;
|
||||
if (event.type === 'labeled') labels.add(event.label); else labels.delete(event.label);
|
||||
}
|
||||
return [...labels];
|
||||
}
|
||||
|
||||
/**
|
||||
* К1. Трек на момент `t` — по меткам, стоящим на задаче до `t`. Трековые метки
|
||||
* разрешает `process-track.mjs`, одним правилом с конвейером: строжайшая из
|
||||
* нескольких `track:*`; прежние `small`/`trivial` — show; без метки — ask для
|
||||
* продукта, show для инфраструктуры (`infra`, §5.1).
|
||||
*/
|
||||
export function trackAt(events, t, { infra = false } = {}) {
|
||||
return labelTrack({ labels: labelsAt(events, t), infrastructure: infra });
|
||||
}
|
||||
|
||||
/** Путь трека: разные треки подряд от `from` (включительно) до `to` (исключая), например `['ship', 'show']`. */
|
||||
export function trackPath(events, { from, to, infra = false } = {}) {
|
||||
const start = toMs(from);
|
||||
const end = toMs(to);
|
||||
const path = [];
|
||||
const push = (track) => { if (path.at(-1) !== track) path.push(track); };
|
||||
push(labelTrack({ labels: labelsAt(events, start, { inclusive: true }), infrastructure: infra }));
|
||||
const moments = [...new Set(labelEvents(events).map((event) => event.at))].filter((moment) => moment > start && moment < end);
|
||||
for (const moment of moments) push(labelTrack({ labels: labelsAt(events, moment, { inclusive: true }), infrastructure: infra }));
|
||||
return path;
|
||||
}
|
||||
|
||||
const SEGMENT_OF_STATUS = {
|
||||
'S1-new': 'queue', 'S2-analysis': 'queue', 'S5-ready': 'queue',
|
||||
'S4-spec-review': 'review', 'S7-code-review': 'review',
|
||||
};
|
||||
|
||||
/**
|
||||
* К2. Отрезки от первой статусной метки до первого `S8-merged`. Статус в
|
||||
* каждый момент — последняя поставленная статусная метка, `blocked` —
|
||||
* наложение поверх статуса: его время вычитается из отрезка под ним. Возврат —
|
||||
* смена статуса `S7 → S6` (и `S7 → S3`, маршрут reclassify #726) или `S4 → S3`;
|
||||
* постановка `S7` поверх `S7` — не возврат и не новый отрезок. Сумма отрезков
|
||||
* равна `lead`. Без `S8` — `null`.
|
||||
*/
|
||||
export function issueSegments(events = []) {
|
||||
const list = labelEvents(events);
|
||||
const s8 = list.find((event) => event.type === 'labeled' && event.label === 'S8-merged');
|
||||
if (!s8) return null;
|
||||
const segments = Object.fromEntries(SEGMENTS.map((name) => [name, 0]));
|
||||
const returns = [];
|
||||
let status = null;
|
||||
let enteredAt = null;
|
||||
let reviewSince = null;
|
||||
let blocked = false;
|
||||
let specReturned = false;
|
||||
let codeReturned = false;
|
||||
let cursor = null;
|
||||
const current = () => {
|
||||
if (blocked) return 'blocked';
|
||||
if (status === 'S3-spec') return specReturned || codeReturned ? 'rework' : 'spec';
|
||||
if (status === 'S6-in-progress') return codeReturned ? 'rework' : 'work';
|
||||
return SEGMENT_OF_STATUS[status] || 'queue';
|
||||
};
|
||||
for (const event of list) {
|
||||
if (cursor !== null && event.at > cursor) {
|
||||
segments[current()] += event.at - cursor;
|
||||
cursor = event.at;
|
||||
}
|
||||
if (event === s8) break;
|
||||
if (event.label === 'blocked') { blocked = event.type === 'labeled'; continue; }
|
||||
if (event.type !== 'labeled' || !STATUS_LABELS.includes(event.label) || event.label === status) continue;
|
||||
if (status === 'S7-code-review' && (event.label === 'S6-in-progress' || event.label === 'S3-spec')) {
|
||||
codeReturned = true;
|
||||
returns.push({ stage: 'code', from: status, to: event.label, since: reviewSince, at: event.at });
|
||||
} else if (status === 'S4-spec-review' && event.label === 'S3-spec') {
|
||||
specReturned = true;
|
||||
returns.push({ stage: 'spec', from: status, to: event.label, since: reviewSince, at: event.at });
|
||||
}
|
||||
status = event.label;
|
||||
if (status === 'S4-spec-review' || status === 'S7-code-review') reviewSince = event.at;
|
||||
if (cursor === null) { cursor = event.at; enteredAt = event.at; }
|
||||
}
|
||||
if (enteredAt === null) enteredAt = s8.at;
|
||||
return { enteredAt, s8At: s8.at, leadMs: s8.at - enteredAt, segments, returns };
|
||||
}
|
||||
|
||||
/** Цвет объявленного вердикта по строке `verdictDeclaration`: первый цвет после слова «Вердикт». */
|
||||
function verdictColour(line) {
|
||||
const match = /(красн)|(жёлт|желт)|(зелён|зелен)/i.exec(String(line).slice(Math.max(0, String(line).indexOf('Вердикт'))));
|
||||
if (!match) return null;
|
||||
return match[1] ? 'red' : match[2] ? 'yellow' : 'green';
|
||||
}
|
||||
|
||||
/**
|
||||
* Вердикт этапа в комментарии: объявление (`verdictDeclaration`) и документ
|
||||
* этой задачи и этого этапа `<MARKER>-<NN>` — то же правило, что у счёта
|
||||
* циклов конвейера (`stageVerdictComments`). Вердикт о чужом документе — `null`.
|
||||
*/
|
||||
export function stageVerdict(body, { stage = 'code', number } = {}) {
|
||||
if (!/^\d+$/.test(String(number ?? ''))) return null;
|
||||
const marker = stage === 'spec' ? 'SPEC-REVIEW' : 'CODE-REVIEW';
|
||||
const text = String(body ?? '');
|
||||
if (!new RegExp(`${marker}-${number}(?![0-9])`).test(text)) return null;
|
||||
const line = verdictDeclaration(text);
|
||||
return line ? verdictColour(line) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* К3. Признак причины возврата в одном комментарии; `null` — комментарий
|
||||
* причины не называет. «Ревью не запускалось» с другим продолжением —
|
||||
* `unknown`: семейство узнано, причина не угадывается.
|
||||
*/
|
||||
export function returnSignal(body, { stage = 'code', number } = {}) {
|
||||
const text = String(body ?? '');
|
||||
const route = ROUTE_RE.exec(text);
|
||||
if (route) return route[1];
|
||||
if (NOT_RUN_RE.test(text)) {
|
||||
if (NOT_RUN_VALIDATE_RE.test(text)) return 'validate-red';
|
||||
if (NOT_RUN_CONFLICT_RE.test(text)) return 'conflict';
|
||||
return 'unknown';
|
||||
}
|
||||
if (MERGE_RES.some((re) => re.test(text))) return 'merge';
|
||||
const colour = stageVerdict(text, { stage, number });
|
||||
if (colour === 'red') return 'verdict-red';
|
||||
if (colour === 'yellow') return 'verdict-yellow';
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Причина возврата — последний комментарий с признаком К3 между постановкой
|
||||
* ревью (`since`) и возвратом (`at`), обе границы включительно. Комментарии
|
||||
* без признака (разговор, «Пока шло ревью…», «Лимит циклов…») причину не
|
||||
* перекрывают. Ничего — `unknown`: метку переставил человек.
|
||||
*/
|
||||
export function returnReason(comments = [], { since, at: returnedAt, stage = 'code', number } = {}) {
|
||||
const from = toMs(since);
|
||||
const to = toMs(returnedAt);
|
||||
const window = (comments || []).filter((comment) => {
|
||||
const moment = toMs(comment.at ?? comment.created_at);
|
||||
return Number.isFinite(moment) && moment >= from && moment <= to;
|
||||
});
|
||||
for (let i = window.length - 1; i >= 0; i--) {
|
||||
const signal = returnSignal(window[i].body, { stage, number });
|
||||
if (signal) return signal;
|
||||
}
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
/** Раунды ревью по комментариям: объявление вердикта этапа своей задачи до `until`. */
|
||||
export function verdictRounds(comments = [], { number, until = Infinity } = {}) {
|
||||
const rounds = [];
|
||||
for (const comment of comments || []) {
|
||||
const moment = toMs(comment.at ?? comment.created_at);
|
||||
if (!Number.isFinite(moment) || moment > toMs(until)) continue;
|
||||
for (const stage of ['code', 'spec']) {
|
||||
const colour = stageVerdict(comment.body, { stage, number });
|
||||
if (!colour) continue;
|
||||
rounds.push({ stage, colour, blocking: colour !== 'green', at: moment });
|
||||
break;
|
||||
}
|
||||
}
|
||||
return rounds;
|
||||
}
|
||||
|
||||
const SHIP_DOC = /^(?:docs\/reviews|legacy\/reviews)\/(?:.*\/)?SHIP-REVIEW-[^/]+\.md$/;
|
||||
|
||||
/**
|
||||
* К4. Находки пакетного ревью ship по документам `SHIP-REVIEW-*.md` живого
|
||||
* каталога и архива: счёт High/Medium/Low — по документу (по задаче
|
||||
* серьёзность не записывается), у задачи — сумма по документам, чей
|
||||
* машинный блок её называет.
|
||||
*/
|
||||
export function shipFindings(reviewDocs = []) {
|
||||
const byIssue = new Map();
|
||||
const docs = [];
|
||||
for (const doc of reviewDocs || []) {
|
||||
if (!SHIP_DOC.test(String(doc?.path || ''))) continue;
|
||||
const block = parseAnchorBlock(doc.text);
|
||||
if (!block) continue;
|
||||
const entry = { path: doc.path, issues: block.issues, high: block.high ?? 0, medium: block.medium ?? 0, low: block.low ?? 0 };
|
||||
docs.push(entry);
|
||||
for (const number of block.issues) {
|
||||
const sum = byIssue.get(number) || { high: 0, medium: 0, low: 0, docs: [] };
|
||||
sum.high += entry.high; sum.medium += entry.medium; sum.low += entry.low; sum.docs.push(doc.path);
|
||||
byIssue.set(number, sum);
|
||||
}
|
||||
}
|
||||
return { byIssue, docs };
|
||||
}
|
||||
|
||||
/** К6. Расход модели по машинным строкам документов ревью; ни одной — `null` («нет данных»). */
|
||||
export function tokenUsage(reviewDocs = []) {
|
||||
const totals = {};
|
||||
let docs = 0;
|
||||
for (const doc of reviewDocs || []) {
|
||||
let found = false;
|
||||
for (const match of String(doc?.text ?? '').matchAll(USAGE_LINE_RE)) {
|
||||
found = true;
|
||||
for (const [, key, value] of match[1].matchAll(/([a-z_]+)=(\d+)/g)) totals[key] = (totals[key] || 0) + Number(value);
|
||||
}
|
||||
if (found) docs += 1;
|
||||
}
|
||||
return docs ? { docs, totals } : null;
|
||||
}
|
||||
|
||||
/** `git log --format=%x1e%H%x1f%cI%x1f%B%x1f --numstat` → коммиты с трейлерами и строками. */
|
||||
export function parseGitLog(text = '') {
|
||||
return String(text).split('\x1e').filter((record) => record.trim()).map((record) => {
|
||||
const [sha, date, body = '', numstat = ''] = record.split('\x1f');
|
||||
return { sha: sha.trim(), date: date?.trim() || null, body, issues: issueTrailers(body), files: parseNumstat(numstat) };
|
||||
}).filter((commit) => /^[0-9a-f]{7,64}$/.test(commit.sha));
|
||||
}
|
||||
|
||||
/** Коммиты `ref` с `since` (дата коммиттера) — с `--numstat`, без переименований. */
|
||||
export function readCommits(git, { ref = 'origin/dev', since } = {}) {
|
||||
const args = ['log', ref, '--no-renames', '--numstat', '--format=%x1e%H%x1f%cI%x1f%B%x1f'];
|
||||
if (since) args.splice(2, 0, `--since=${new Date(toMs(since)).toISOString()}`);
|
||||
return parseGitLog(git(args));
|
||||
}
|
||||
|
||||
/** Строка объёма К7: не класс D (`classify`) и не `docs/reviews/**`. */
|
||||
const countsToVolume = (path) => classify(path) !== 'D' && !String(path).startsWith('docs/reviews/');
|
||||
|
||||
/**
|
||||
* Изменения задачи по коммитам с трейлером `Issue: #NN`, кроме коммитов
|
||||
* `Release:` (они несут трейлеры всех задач беты, бандлы и версию манифеста):
|
||||
* объём К7 (`+/−` без класса D и `docs/reviews/**`) и файлы для признака
|
||||
* инфраструктуры К1.
|
||||
*/
|
||||
export function issueChanges(commits = []) {
|
||||
const byIssue = new Map();
|
||||
for (const commit of commits || []) {
|
||||
if (/^Release:/m.test(String(commit.body || ''))) continue;
|
||||
for (const number of commit.issues || issueTrailers(commit.body)) {
|
||||
const entry = byIssue.get(number) || { lines: 0, files: new Set(), commits: 0 };
|
||||
entry.commits += 1;
|
||||
for (const file of commit.files || []) {
|
||||
entry.files.add(file.path);
|
||||
if (countsToVolume(file.path)) entry.lines += (file.added ?? 0) + (file.deleted ?? 0);
|
||||
}
|
||||
byIssue.set(number, entry);
|
||||
}
|
||||
}
|
||||
return byIssue;
|
||||
}
|
||||
|
||||
/** Инфраструктура (§1): в коммитах задачи есть файлы и ни одного класса A. */
|
||||
export const isInfra = (change) => Boolean(change && change.files.size && [...change.files].every((path) => classify(path) !== 'A'));
|
||||
|
||||
/** Корзина объёма К7: ≤ 30, 31–200, 201–1000, > 1000 строк. */
|
||||
export function volumeBucket(lines) {
|
||||
if (!Number.isFinite(lines)) return null;
|
||||
if (lines <= 30) return VOLUME_BUCKETS[0];
|
||||
if (lines <= 200) return VOLUME_BUCKETS[1];
|
||||
if (lines <= 1000) return VOLUME_BUCKETS[2];
|
||||
return VOLUME_BUCKETS[3];
|
||||
}
|
||||
|
||||
/**
|
||||
* Задача для разделов по трекам: трек на момент первого `S8-merged`, путь
|
||||
* трека, отрезки, возвраты и раунды с треком своего момента, находки ship.
|
||||
* Без `S8` — `null`. Усечённый таймлайн — строка без отрезков (`truncated`).
|
||||
*/
|
||||
export function issueTrackMetrics(issue, events = [], { change = null, ship = null, truncated = false } = {}) {
|
||||
const number = Number(issue.number);
|
||||
const s8 = labelEvents(events).find((event) => event.type === 'labeled' && event.label === 'S8-merged');
|
||||
if (!s8) return null;
|
||||
const infra = isInfra(change);
|
||||
const base = {
|
||||
number, title: String(issue.title || ''), stateReason: issue.state_reason || null, s8At: s8.at,
|
||||
infra, volume: change ? change.lines : null, bucket: change ? volumeBucket(change.lines) : null,
|
||||
};
|
||||
if (truncated) return { ...base, truncated: true, track: null, path: [], leadMs: null, segments: null, returns: [], rounds: [], ship: null };
|
||||
const seg = issueSegments(events);
|
||||
const comments = commentEvents(events);
|
||||
const track = trackAt(events, s8.at, { infra });
|
||||
return {
|
||||
...base,
|
||||
truncated: false,
|
||||
track,
|
||||
path: trackPath(events, { from: seg.enteredAt, to: s8.at, infra }),
|
||||
enteredAt: seg.enteredAt,
|
||||
leadMs: seg.leadMs,
|
||||
segments: seg.segments,
|
||||
returns: seg.returns.map((ret) => ({
|
||||
stage: ret.stage, from: ret.from, to: ret.to, at: ret.at,
|
||||
reason: returnReason(comments, { since: ret.since, at: ret.at, stage: ret.stage, number }),
|
||||
track: trackAt(events, ret.at, { infra }),
|
||||
})),
|
||||
rounds: verdictRounds(comments, { number, until: s8.at }).map((round) => ({ ...round, track: trackAt(events, round.at, { infra }) })),
|
||||
ship: track === 'ship' ? (ship || { high: 0, medium: 0, low: 0, docs: [] }) : null,
|
||||
};
|
||||
}
|
||||
|
||||
const trackOrder = (track) => (TRACKS.includes(track) ? TRACKS.indexOf(track) : TRACKS.length);
|
||||
|
||||
/**
|
||||
* Разделы «По трекам»: задачи по треку на момент S8; возвраты и раунды — по
|
||||
* треку своего момента. Находки ship — сумма по разным документам, которые
|
||||
* называют ship-задачи раздела: документ на две задачи считается один раз.
|
||||
*/
|
||||
export function trackSection(rows = [], { shipDocs = [] } = {}) {
|
||||
const counted = rows.filter((row) => !row.truncated);
|
||||
const tracks = [...new Set([...TRACKS, ...counted.map((row) => row.track)])].sort((a, b) => trackOrder(a) - trackOrder(b));
|
||||
const byTrack = tracks.map((track) => {
|
||||
const own = counted.filter((row) => row.track === track);
|
||||
const medians = Object.fromEntries(['lead', ...SEGMENTS].map((name) => [name, medianHours(own.map((row) => (name === 'lead' ? row.leadMs : row.segments[name])))]));
|
||||
let ship = null;
|
||||
if (track === 'ship') {
|
||||
const numbers = new Set(own.map((row) => row.number));
|
||||
const docs = (shipDocs || []).filter((doc) => doc.issues.some((number) => numbers.has(number)));
|
||||
ship = {
|
||||
issues: own.length,
|
||||
covered: own.filter((row) => row.ship?.docs.length).length,
|
||||
docs: docs.length,
|
||||
high: docs.reduce((sum, doc) => sum + doc.high, 0),
|
||||
medium: docs.reduce((sum, doc) => sum + doc.medium, 0),
|
||||
low: docs.reduce((sum, doc) => sum + doc.low, 0),
|
||||
};
|
||||
}
|
||||
return { track, n: own.length, medians, ship };
|
||||
});
|
||||
const events = tracks.map((track) => {
|
||||
const returns = counted.flatMap((row) => row.returns).filter((ret) => ret.track === track);
|
||||
const rounds = counted.flatMap((row) => row.rounds).filter((round) => round.track === track);
|
||||
return {
|
||||
track,
|
||||
returns: returns.length,
|
||||
reasons: Object.fromEntries(RETURN_REASONS.map((reason) => [reason, returns.filter((ret) => ret.reason === reason).length])),
|
||||
rounds: Object.fromEntries(['code', 'spec'].map((stage) => [stage, {
|
||||
blocking: rounds.filter((round) => round.stage === stage && round.blocking).length,
|
||||
green: rounds.filter((round) => round.stage === stage && !round.blocking).length,
|
||||
}])),
|
||||
};
|
||||
});
|
||||
return {
|
||||
n: counted.length,
|
||||
byTrack, events,
|
||||
truncated: rows.filter((row) => row.truncated).map((row) => row.number),
|
||||
changed: counted.filter((row) => row.path.length > 1).map((row) => ({ number: row.number, path: row.path })),
|
||||
rows: [...rows].sort((a, b) => a.number - b.number),
|
||||
};
|
||||
}
|
||||
|
||||
/** Стадия конвейера по имени job тела — части после « / »: «Страж…», «Ревью: материал…», … */
|
||||
export function jobStage(name = '') {
|
||||
const text = String(name);
|
||||
const own = text.includes(' / ') ? text.slice(text.indexOf(' / ') + 3) : text;
|
||||
if (/^Страж/.test(own)) return 'guard';
|
||||
if (/^Ревью: материал/.test(own)) return 'prepare';
|
||||
if (/^Ревью: работа модели/.test(own)) return 'model';
|
||||
if (/^Ревью: публикация/.test(own)) return 'integrate';
|
||||
return 'other';
|
||||
}
|
||||
|
||||
const PROCESS_TITLE = /^process #(\d+) · /;
|
||||
|
||||
/**
|
||||
* Прогоны, для которых запрашиваются jobs (К5): конвейер `process #NN · …` и
|
||||
* Validate, кроме skipped (у них нет ни одной выполненной job), не больше `cap`.
|
||||
*/
|
||||
export function jobRuns(runs = [], cap = JOBS_RUN_CAP) {
|
||||
const eligible = (runs || []).filter((run) => run?.conclusion !== 'skipped'
|
||||
&& (PROCESS_TITLE.test(String(run.display_title || '')) || String(run.name || '') === VALIDATE_WORKFLOW));
|
||||
return { total: eligible.length, selected: eligible.slice(0, cap) };
|
||||
}
|
||||
|
||||
const jobMs = (job) => {
|
||||
const started = at(job?.started_at);
|
||||
const ended = at(job?.completed_at);
|
||||
return Number.isFinite(started) && Number.isFinite(ended) && ended > started ? ended - started : 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* К5. Job-минуты конвейера по стадиям — всего и по треку задачи на момент
|
||||
* прогона (К1); Validate — всего и по событию. Jobs прогона недоступны
|
||||
* (`null`: 403, истёк срок хранения) — прогон не даёт данных; ни одного
|
||||
* прогона с данными — `null` («нет данных»), а не ноль.
|
||||
*/
|
||||
export function stageMinutes({ runs = [], jobsByRun = new Map(), trackOf = () => null, cap = JOBS_RUN_CAP } = {}) {
|
||||
const { total, selected } = jobRuns(runs, cap);
|
||||
const stagesMs = () => Object.fromEntries([...PIPELINE_STAGES, 'other'].map((stage) => [stage, 0]));
|
||||
const processAll = stagesMs();
|
||||
const processByTrack = {};
|
||||
const validateByEvent = {};
|
||||
let validateMs = 0;
|
||||
let processRuns = 0;
|
||||
let validateRuns = 0;
|
||||
let unavailable = 0;
|
||||
for (const run of selected) {
|
||||
const jobs = jobsByRun.get(run.id) ?? jobsByRun.get(String(run.id)) ?? null;
|
||||
if (!Array.isArray(jobs)) { unavailable += 1; continue; }
|
||||
const process = PROCESS_TITLE.exec(String(run.display_title || ''));
|
||||
if (process) {
|
||||
processRuns += 1;
|
||||
const track = trackOf(Number(process[1]), at(run.run_started_at || run.created_at)) || '—';
|
||||
processByTrack[track] ||= stagesMs();
|
||||
for (const job of jobs) {
|
||||
const stage = jobStage(job.name);
|
||||
processAll[stage] += jobMs(job);
|
||||
processByTrack[track][stage] += jobMs(job);
|
||||
}
|
||||
} else {
|
||||
validateRuns += 1;
|
||||
const event = String(run.event || 'other');
|
||||
for (const job of jobs) {
|
||||
validateMs += jobMs(job);
|
||||
validateByEvent[event] = (validateByEvent[event] || 0) + jobMs(job);
|
||||
}
|
||||
}
|
||||
}
|
||||
const toMinutes = (stages) => Object.fromEntries(Object.entries(stages).map(([stage, ms]) => [stage, minutes(ms)]));
|
||||
return {
|
||||
runs: total,
|
||||
fetched: selected.length,
|
||||
truncated: total > selected.length ? { fetched: selected.length, total } : null,
|
||||
unavailable,
|
||||
process: processRuns ? {
|
||||
runs: processRuns,
|
||||
stages: toMinutes(processAll),
|
||||
byTrack: Object.fromEntries(Object.entries(processByTrack)
|
||||
.sort(([a], [b]) => trackOrder(a) - trackOrder(b)).map(([track, stages]) => [track, toMinutes(stages)])),
|
||||
} : null,
|
||||
validate: validateRuns ? {
|
||||
runs: validateRuns,
|
||||
minutes: minutes(validateMs),
|
||||
byEvent: Object.fromEntries(Object.entries(validateByEvent).map(([event, ms]) => [event, minutes(ms)])),
|
||||
} : null,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* К7. Сравнение сопоставимых задач до и после `cutover`: первый `S8-merged`
|
||||
* в `[cutover − days, cutover)` и `[cutover, min(cutover + days, until))`,
|
||||
* когорта — трек на момент S8 и корзина объёма. n < `MIN_COHORT` на любой
|
||||
* стороне — «мало данных», разницы нет. Задачи без коммитов с трейлером
|
||||
* объёма не имеют и в когорты не входят.
|
||||
*/
|
||||
export function compareCohorts(rows = [], { cutover = TRACKS_CUTOVER, days = COMPARE_DAYS, until = null } = {}) {
|
||||
const border = toMs(cutover);
|
||||
const beforeFrom = border - days * DAY_MS;
|
||||
const afterTo = Math.min(border + days * DAY_MS, until == null ? Infinity : toMs(until));
|
||||
const sideOf = (row) => {
|
||||
if (row.s8At >= beforeFrom && row.s8At < border) return 'before';
|
||||
if (row.s8At >= border && row.s8At < afterTo) return 'after';
|
||||
return null;
|
||||
};
|
||||
const inWindow = rows.filter((row) => !row.truncated && sideOf(row));
|
||||
const noCommits = inWindow.filter((row) => row.bucket == null).map((row) => row.number).sort((a, b) => a - b);
|
||||
const cohorts = new Map();
|
||||
for (const row of inWindow.filter((r) => r.bucket != null)) {
|
||||
const key = `${row.track} · ${row.bucket}`;
|
||||
const cohort = cohorts.get(key) || { key, track: row.track, bucket: row.bucket, before: [], after: [] };
|
||||
cohort[sideOf(row)].push(row);
|
||||
cohorts.set(key, cohort);
|
||||
}
|
||||
const stats = (side) => ({
|
||||
n: side.length,
|
||||
lead: medianHours(side.map((row) => row.leadMs)),
|
||||
work: medianHours(side.map((row) => row.segments.work)),
|
||||
review: medianHours(side.map((row) => row.segments.review)),
|
||||
rework: medianHours(side.map((row) => row.segments.rework)),
|
||||
returns: side.length ? Math.round(mean(side.map((row) => row.returns.length)) * 100) / 100 : null,
|
||||
});
|
||||
const delta = (a, b) => (a == null || b == null ? null : Math.round((b - a) * 100) / 100);
|
||||
const list = [...cohorts.values()]
|
||||
.sort((a, b) => trackOrder(a.track) - trackOrder(b.track) || VOLUME_BUCKETS.indexOf(a.bucket) - VOLUME_BUCKETS.indexOf(b.bucket))
|
||||
.map((cohort) => {
|
||||
const before = stats(cohort.before);
|
||||
const after = stats(cohort.after);
|
||||
const enough = before.n >= MIN_COHORT && after.n >= MIN_COHORT;
|
||||
return {
|
||||
key: cohort.key, track: cohort.track, bucket: cohort.bucket, before, after, enough,
|
||||
diff: enough ? Object.fromEntries(['lead', 'work', 'review', 'rework', 'returns'].map((name) => [name, delta(before[name], after[name])])) : null,
|
||||
};
|
||||
});
|
||||
return {
|
||||
cutover: new Date(border).toISOString().slice(0, 10),
|
||||
days,
|
||||
before: { from: new Date(beforeFrom).toISOString(), to: new Date(border).toISOString() },
|
||||
after: { from: new Date(border).toISOString(), to: Number.isFinite(afterTo) ? new Date(afterTo).toISOString() : null },
|
||||
cohorts: list,
|
||||
noCommits,
|
||||
};
|
||||
}
|
||||
|
||||
/** Собрать всё в один отчёт. */
|
||||
export function buildReport({ since, until, issues = [], timelines = new Map(), reviewFiles = [], runs = [], jobsByRun = null }) {
|
||||
export function buildReport({
|
||||
since, until, issues = [], timelines = new Map(), reviewFiles = [], runs = [], jobsByRun = null,
|
||||
// #728: задачи для разделов по трекам (по умолчанию — те же `issues`), усечённые
|
||||
// таймлайны, тексты документов ревью, коммиты dev и окно сравнения.
|
||||
allIssues = null, timelineTruncated = new Set(), reviewDocs = [], commits = [], compare = {},
|
||||
}) {
|
||||
const perIssue = issues.map((issue) => issueMetrics(issue, timelines.get(Number(issue.number)) || []));
|
||||
const rounds = reviewRounds(reviewFiles);
|
||||
const completed = perIssue.filter((issue) => issue.stateReason === 'completed');
|
||||
@@ -190,6 +775,36 @@ export function buildReport({ since, until, issues = [], timelines = new Map(),
|
||||
runs: runMetrics(runs),
|
||||
pipeline: pipelineMetrics(runs),
|
||||
jobs: jobsByRun ? jobMinutes(jobsByRun) : null,
|
||||
...trackReport({ since, until, issues: allIssues || issues, timelines, timelineTruncated, reviewDocs, runs, jobsByRun, commits, compare }),
|
||||
};
|
||||
}
|
||||
|
||||
/** #728: разделы по трекам, job-минуты по стадиям, токены и сравнение до/после. */
|
||||
function trackReport({ since, until, issues, timelines, timelineTruncated, reviewDocs, runs, jobsByRun, commits, compare }) {
|
||||
const changes = issueChanges(commits);
|
||||
const ship = shipFindings(reviewDocs);
|
||||
const seen = new Set();
|
||||
const rows = [];
|
||||
for (const issue of issues || []) {
|
||||
const number = Number(issue.number);
|
||||
if (seen.has(number)) continue;
|
||||
seen.add(number);
|
||||
const row = issueTrackMetrics(issue, timelines.get(number) || [], {
|
||||
change: changes.get(number) || null, ship: ship.byIssue.get(number) || null, truncated: timelineTruncated.has(number),
|
||||
});
|
||||
if (row) rows.push(row);
|
||||
}
|
||||
const from = at(since);
|
||||
const to = at(until);
|
||||
const trackOf = (number, moment) => {
|
||||
const events = timelines.get(number);
|
||||
return events && Number.isFinite(moment) ? trackAt(events, moment, { infra: isInfra(changes.get(number)) }) : null;
|
||||
};
|
||||
return {
|
||||
tracks: trackSection(rows.filter((row) => row.s8At >= from && row.s8At <= to), { shipDocs: ship.docs }),
|
||||
stages: jobsByRun ? stageMinutes({ runs, jobsByRun, trackOf }) : null,
|
||||
tokens: tokenUsage(reviewDocs),
|
||||
compare: compareCohorts(rows, { cutover: compare.cutover ?? TRACKS_CUTOVER, days: compare.days ?? COMPARE_DAYS, until }),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -236,9 +851,139 @@ export function renderMarkdown(report) {
|
||||
}
|
||||
lines.push('');
|
||||
lines.push('</details>');
|
||||
// #728: новые разделы — после прежних; прежние строки не меняются.
|
||||
if (report.tracks) renderTracks(lines, report.tracks);
|
||||
if ('stages' in report) renderStages(lines, report.stages);
|
||||
if ('tokens' in report) renderTokens(lines, report.tokens);
|
||||
if (report.compare) renderCompare(lines, report.compare);
|
||||
return `${lines.join('\n')}\n`;
|
||||
}
|
||||
|
||||
const h = (value) => fmt(value);
|
||||
const hoursOf = (ms) => (ms == null ? null : hours(ms));
|
||||
const isoDay = (value) => String(value || '').slice(0, 10);
|
||||
|
||||
function renderTracks(lines, t) {
|
||||
lines.push('');
|
||||
lines.push('### По трекам');
|
||||
lines.push('');
|
||||
lines.push(`Задачи с первым \`S8-merged\` в окне: **${t.n}**. Трек — на момент первого \`S8-merged\` (прежние \`small\`/\`trivial\` — show, без метки — ask для продукта и show для инфраструктуры, §5.1). Отрезки — от первой статусной метки до первого \`S8-merged\`, сумма равна lead: queue — \`S1\`/\`S2\`/\`S5\`; spec — \`S3\` до первого возврата с ревью ТЗ; work — \`S6\` до первого возврата с код-ревью; review — \`S4\`/\`S7\` вместе с ожиданием Validate; rework — \`S3\`/\`S6\` после возврата; blocked — под \`blocked\`, вычитается из отрезка под ним.`);
|
||||
lines.push('');
|
||||
lines.push('| Трек | n | lead, ч | queue | spec | work | review | rework | blocked | Находки ship |');
|
||||
lines.push('|---|---:|---:|---:|---:|---:|---:|---:|---:|---|');
|
||||
for (const row of t.byTrack) {
|
||||
const m = row.medians;
|
||||
const ship = row.ship
|
||||
? `покрыто ${row.ship.covered} из ${row.ship.issues}, документов ${row.ship.docs}${row.ship.docs ? `: High ${row.ship.high} · Medium ${row.ship.medium} · Low ${row.ship.low}` : ''}`
|
||||
: '—';
|
||||
lines.push(`| ${row.track} | ${row.n} | ${h(m.lead)} | ${h(m.queue)} | ${h(m.spec)} | ${h(m.work)} | ${h(m.review)} | ${h(m.rework)} | ${h(m.blocked)} | ${ship} |`);
|
||||
}
|
||||
lines.push('');
|
||||
lines.push('Медианы в часах. Возвраты и раунды — по треку на момент события. Возврат — `S7 → S6`/`S3` или `S4 → S3`; причина — последний комментарий с признаком между постановкой ревью и возвратом, без признака — `unknown`. Раунд — объявление вердикта этапа в комментарии.');
|
||||
lines.push('');
|
||||
lines.push(`| Трек | Возвратов | ${RETURN_REASONS.join(' | ')} | Код-ревью: блок. / зел. | Ревью ТЗ: блок. / зел. |`);
|
||||
lines.push(`|---|---:|${RETURN_REASONS.map(() => '---:').join('|')}|---|---|`);
|
||||
for (const row of t.events) {
|
||||
lines.push(`| ${row.track} | ${row.returns} | ${RETURN_REASONS.map((reason) => row.reasons[reason]).join(' | ')} | ${row.rounds.code.blocking} / ${row.rounds.code.green} | ${row.rounds.spec.blocking} / ${row.rounds.spec.green} |`);
|
||||
}
|
||||
if (t.changed.length) {
|
||||
lines.push('');
|
||||
lines.push(`Трек менялся: ${t.changed.map((row) => `#${row.number} ${row.path.join('→')}`).join(', ')}.`);
|
||||
}
|
||||
if (t.truncated.length) {
|
||||
lines.push('');
|
||||
lines.push(`Таймлайн усечён (больше ${TIMELINE_PAGE_CAP} страниц), в отрезки не входит: ${t.truncated.map((n) => `#${n}`).join(', ')}.`);
|
||||
}
|
||||
if (t.rows.length) {
|
||||
lines.push('');
|
||||
lines.push('<details><summary>По задачам (треки)</summary>');
|
||||
lines.push('');
|
||||
lines.push('| # | Трек | Путь | Исход | lead, ч | work | review | rework | Возвраты | Объём | Находки ship |');
|
||||
lines.push('|---|---|---|---|---:|---:|---:|---:|---|---:|---|');
|
||||
for (const row of t.rows) {
|
||||
if (row.truncated) {
|
||||
lines.push(`| #${row.number} | таймлайн усечён | — | ${row.stateReason || '—'} | — | — | — | — | — | ${fmt(row.volume)} | — |`);
|
||||
continue;
|
||||
}
|
||||
const returns = row.returns.length ? row.returns.map((ret) => ret.reason).join(', ') : '—';
|
||||
const ship = row.ship ? (row.ship.docs.length ? `H ${row.ship.high} · M ${row.ship.medium} · L ${row.ship.low}` : 'не ревьюирована') : '—';
|
||||
lines.push(`| #${row.number} | ${row.track} | ${row.path.join('→')} | ${row.stateReason || '—'} | ${h(hoursOf(row.leadMs))} | ${h(hoursOf(row.segments.work))} | ${h(hoursOf(row.segments.review))} | ${h(hoursOf(row.segments.rework))} | ${returns} | ${fmt(row.volume)} | ${ship} |`);
|
||||
}
|
||||
lines.push('');
|
||||
lines.push('</details>');
|
||||
}
|
||||
}
|
||||
|
||||
function renderStages(lines, s) {
|
||||
lines.push('');
|
||||
lines.push('### Job-минуты по стадиям');
|
||||
lines.push('');
|
||||
if (!s) {
|
||||
lines.push('Нет данных: jobs прогонов не запрашивались.');
|
||||
return;
|
||||
}
|
||||
if (!s.process) {
|
||||
lines.push('Конвейер: нет данных (jobs недоступны или прогонов нет).');
|
||||
} else {
|
||||
const tracks = Object.keys(s.process.byTrack);
|
||||
lines.push(`Конвейер, ${s.process.runs} прогонов с jobs; трек — задачи на момент прогона.`);
|
||||
lines.push('');
|
||||
lines.push(`| Стадия | Всего, мин | ${tracks.join(' | ')} |`);
|
||||
lines.push(`|---|---:|${tracks.map(() => '---:').join('|')}|`);
|
||||
for (const stage of [...PIPELINE_STAGES, 'other']) {
|
||||
if (stage === 'other' && !s.process.stages.other) continue;
|
||||
lines.push(`| ${stage} | ${s.process.stages[stage]} | ${tracks.map((track) => s.process.byTrack[track][stage]).join(' | ')} |`);
|
||||
}
|
||||
}
|
||||
lines.push('');
|
||||
lines.push(s.validate
|
||||
? `Validate: **${s.validate.minutes}** мин за ${s.validate.runs} прогонов (${Object.entries(s.validate.byEvent).map(([event, value]) => `${event} ${value}`).join(', ') || '—'}).`
|
||||
: 'Validate: нет данных (jobs недоступны или прогонов нет).');
|
||||
if (s.truncated) {
|
||||
lines.push('');
|
||||
lines.push(`Jobs запрошены не для всех прогонов — усечено: ${s.truncated.fetched} из ${s.truncated.total} прогонов.`);
|
||||
}
|
||||
if (s.unavailable) {
|
||||
lines.push('');
|
||||
lines.push(`Jobs недоступны у ${s.unavailable} из ${s.fetched} прогонов — в минуты не входят.`);
|
||||
}
|
||||
}
|
||||
|
||||
function renderTokens(lines, tokens) {
|
||||
lines.push('');
|
||||
lines.push('### Токены');
|
||||
lines.push('');
|
||||
lines.push(tokens
|
||||
? `Токены по ${tokens.docs} документам ревью: ${Object.entries(tokens.totals).map(([key, value]) => `${key} ${value}`).join(' · ')}.`
|
||||
: `${TOKENS_NO_DATA}.`);
|
||||
}
|
||||
|
||||
function renderCompare(lines, c) {
|
||||
lines.push('');
|
||||
lines.push(`### До и после ${c.cutover}`);
|
||||
lines.push('');
|
||||
lines.push(`Первый \`S8-merged\` в [${isoDay(c.before.from)}, ${isoDay(c.before.to)}) и [${isoDay(c.after.from)}, ${c.after.to ? isoDay(c.after.to) : '…'}), окно ${c.days} дн. Когорта — трек на момент S8 и объём задачи: \`+/−\` строк коммитов \`Issue: #NN\` без \`Release:\`, класса D и \`docs/reviews/**\` (корзины ${VOLUME_BUCKETS.join(', ')}). Медианы в часах «до → после (разница)»; n < ${MIN_COHORT} на любой стороне — мало данных. Job-минуты в сравнение не входят.`);
|
||||
lines.push('');
|
||||
if (!c.cohorts.length) {
|
||||
lines.push('Мало данных: в окне сравнения нет задач с коммитами.');
|
||||
} else {
|
||||
lines.push('| Когорта | n до | n после | lead | work | review | rework | Возвратов (среднее) |');
|
||||
lines.push('|---|---:|---:|---|---|---|---|---|');
|
||||
const pair = (cohort, name) => `${fmt(cohort.before[name])} → ${fmt(cohort.after[name])} (${cohort.diff[name] == null ? '—' : `${cohort.diff[name] > 0 ? '+' : ''}${fmt(cohort.diff[name])}`})`;
|
||||
for (const cohort of c.cohorts) {
|
||||
if (!cohort.enough) {
|
||||
lines.push(`| ${cohort.key} | ${cohort.before.n} | ${cohort.after.n} | мало данных | | | | |`);
|
||||
continue;
|
||||
}
|
||||
lines.push(`| ${cohort.key} | ${cohort.before.n} | ${cohort.after.n} | ${['lead', 'work', 'review', 'rework', 'returns'].map((name) => pair(cohort, name)).join(' | ')} |`);
|
||||
}
|
||||
}
|
||||
if (c.noCommits.length) {
|
||||
lines.push('');
|
||||
lines.push(`Без коммитов с трейлером (объёма нет, в когорты не входят): ${c.noCommits.map((n) => `#${n}`).join(', ')}.`);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// gh-обвязка: только чтение.
|
||||
|
||||
@@ -246,31 +991,37 @@ function ghJson(args) {
|
||||
return JSON.parse(execFileSync('gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }));
|
||||
}
|
||||
|
||||
export function fetchSnapshot({ repo, since, until, gh = ghJson, git = null }) {
|
||||
/**
|
||||
* Снимок для отчёта: только чтение GitHub API и локального git.
|
||||
*
|
||||
* - issue `state=all` с `since` самого раннего окна (неделя отчёта или окно
|
||||
* сравнения К7): задачи в `S8-merged` закрываются только с бетой (§2.8).
|
||||
* Прежняя выборка (`issues`) — закрытые в окне, как раньше;
|
||||
* - таймлайн — у прежней выборки, у задач с `S8-merged` или закрытых и у
|
||||
* задач прогонов конвейера окна; не дальше `TIMELINE_PAGE_CAP` страниц,
|
||||
* иначе задача помечается «таймлайн усечён»;
|
||||
* - jobs (К5) — для `jobRuns`, недоступные jobs — `null`;
|
||||
* - имена документов ревью, тексты `SHIP-REVIEW-*.md` и документов со строкой
|
||||
* расхода, коммиты `origin/dev` с `--numstat` за окно сравнения.
|
||||
*/
|
||||
export function fetchSnapshot({ repo, since, until, gh = ghJson, git = null, compare = {} }) {
|
||||
const sinceIso = new Date(since).toISOString();
|
||||
const untilMs = at(until);
|
||||
const issues = [];
|
||||
for (let page = 1; page <= 5; page++) {
|
||||
const batch = gh(['api', `repos/${repo}/issues?state=closed&since=${encodeURIComponent(sinceIso)}&per_page=100&page=${page}`]);
|
||||
const cutover = toMs(compare.cutover ?? TRACKS_CUTOVER);
|
||||
const days = Number(compare.days ?? COMPARE_DAYS);
|
||||
const earliestIso = new Date(Math.min(at(sinceIso), cutover - days * DAY_MS)).toISOString();
|
||||
const all = [];
|
||||
for (let page = 1; page <= 10; page++) {
|
||||
const batch = gh(['api', `repos/${repo}/issues?state=all&since=${encodeURIComponent(earliestIso)}&per_page=100&page=${page}`]);
|
||||
if (!Array.isArray(batch) || !batch.length) break;
|
||||
for (const issue of batch) {
|
||||
if (issue.pull_request) continue;
|
||||
const closed = at(issue.closed_at);
|
||||
if (Number.isFinite(closed) && closed >= at(sinceIso) && closed <= untilMs) issues.push(issue);
|
||||
}
|
||||
all.push(...batch.filter((issue) => !issue.pull_request));
|
||||
if (batch.length < 100) break;
|
||||
}
|
||||
const timelines = new Map();
|
||||
for (const issue of issues) {
|
||||
const events = [];
|
||||
for (let page = 1; page <= 3; page++) {
|
||||
const batch = gh(['api', `repos/${repo}/issues/${issue.number}/timeline?per_page=100&page=${page}`, '-H', 'Accept: application/vnd.github+json']);
|
||||
if (!Array.isArray(batch) || !batch.length) break;
|
||||
events.push(...batch);
|
||||
if (batch.length < 100) break;
|
||||
}
|
||||
timelines.set(Number(issue.number), events);
|
||||
}
|
||||
const closedInWindow = (issue) => {
|
||||
const closed = at(issue.closed_at);
|
||||
return Number.isFinite(closed) && closed >= at(sinceIso) && closed <= untilMs;
|
||||
};
|
||||
const issues = all.filter(closedInWindow);
|
||||
const runs = [];
|
||||
for (let page = 1; page <= 15; page++) {
|
||||
const batch = gh(['api', `repos/${repo}/actions/runs?created=${encodeURIComponent(`${sinceIso.slice(0, 10)}..${new Date(untilMs).toISOString().slice(0, 10)}`)}&per_page=100&page=${page}`]);
|
||||
@@ -278,25 +1029,78 @@ export function fetchSnapshot({ repo, since, until, gh = ghJson, git = null }) {
|
||||
runs.push(...rows);
|
||||
if (rows.length < 100) break;
|
||||
}
|
||||
const reviewFiles = git
|
||||
? reviewDocNames(git(['ls-tree', '-r', '--name-only', 'HEAD', '--', 'docs/reviews', 'legacy/reviews']))
|
||||
: [];
|
||||
return { issues, timelines, runs, reviewFiles };
|
||||
const { selected } = jobRuns(runs);
|
||||
const runIssues = new Set(selected.map((run) => Number(PROCESS_TITLE.exec(String(run.display_title || ''))?.[1])).filter(Number.isFinite));
|
||||
const allIssues = all.filter((issue) => closedInWindow(issue)
|
||||
|| (issue.labels || []).some((label) => (label?.name ?? label) === 'S8-merged')
|
||||
|| (issue.state === 'closed' && at(issue.closed_at) >= at(earliestIso))
|
||||
|| runIssues.has(Number(issue.number)));
|
||||
const timelines = new Map();
|
||||
const timelineTruncated = new Set();
|
||||
for (const issue of allIssues) {
|
||||
const events = [];
|
||||
for (let page = 1; page <= TIMELINE_PAGE_CAP; page++) {
|
||||
const batch = gh(['api', `repos/${repo}/issues/${issue.number}/timeline?per_page=100&page=${page}`, '-H', 'Accept: application/vnd.github+json']);
|
||||
if (!Array.isArray(batch) || !batch.length) break;
|
||||
events.push(...batch);
|
||||
if (batch.length < 100) break;
|
||||
if (page === TIMELINE_PAGE_CAP) timelineTruncated.add(Number(issue.number));
|
||||
}
|
||||
timelines.set(Number(issue.number), events);
|
||||
}
|
||||
const jobsByRun = new Map();
|
||||
for (const run of selected) {
|
||||
try {
|
||||
const jobs = [];
|
||||
for (let page = 1; page <= 3; page++) {
|
||||
const batch = gh(['api', `repos/${repo}/actions/runs/${run.id}/jobs?per_page=100&page=${page}`]);
|
||||
const rows = batch?.jobs || [];
|
||||
jobs.push(...rows);
|
||||
if (rows.length < 100) break;
|
||||
}
|
||||
jobsByRun.set(run.id, jobs);
|
||||
} catch {
|
||||
jobsByRun.set(run.id, null); // 403, истёк срок хранения: «нет данных», а не ноль
|
||||
}
|
||||
}
|
||||
let reviewFiles = [];
|
||||
const reviewDocs = [];
|
||||
let commits = [];
|
||||
if (git) {
|
||||
const listing = git(['ls-tree', '-r', '--name-only', 'HEAD', '--', 'docs/reviews', 'legacy/reviews']);
|
||||
reviewFiles = reviewDocNames(listing);
|
||||
const paths = String(listing).split('\n').map((path) => path.trim()).filter(Boolean);
|
||||
let usage = [];
|
||||
try {
|
||||
usage = git(['grep', '-l', '-e', 'hp:usage', 'HEAD', '--', 'docs/reviews', 'legacy/reviews'])
|
||||
.split('\n').map((line) => line.trim().replace(/^HEAD:/, '')).filter(Boolean);
|
||||
} catch { /* git grep без совпадений выходит с кодом 1 */ }
|
||||
for (const path of new Set([...paths.filter((p) => SHIP_DOC.test(p)), ...usage])) {
|
||||
reviewDocs.push({ path, text: git(['show', `HEAD:${path}`]) });
|
||||
}
|
||||
let ref = 'origin/dev';
|
||||
try { git(['rev-parse', '--verify', '-q', ref]); } catch { ref = 'HEAD'; }
|
||||
// Коммиты задачи бывают раньше её S8: запас в одно окно до начала сравнения.
|
||||
commits = readCommits(git, { ref, since: at(earliestIso) - days * DAY_MS });
|
||||
}
|
||||
return { issues, allIssues, timelines, timelineTruncated, runs, jobsByRun, reviewFiles, reviewDocs, commits };
|
||||
}
|
||||
|
||||
if (isMainModule(import.meta.url)) {
|
||||
const arg = (name, fallback) => process.argv.find((a) => a.startsWith(`--${name}=`))?.slice(name.length + 3) ?? fallback;
|
||||
const repo = arg('repo', process.env.GITHUB_REPOSITORY);
|
||||
if (!repo) {
|
||||
console.error('usage: process-metrics.mjs --repo=<owner/repo> [--days=7] [--until=ISO] [--output=file.md] [--json=file.json]');
|
||||
const compare = { cutover: arg('compare', TRACKS_CUTOVER), days: Number(arg('compare-days', String(COMPARE_DAYS))) };
|
||||
if (!repo || !Number.isFinite(at(compare.cutover)) || !(compare.days > 0)) {
|
||||
console.error('usage: process-metrics.mjs --repo=<owner/repo> [--days=7] [--until=ISO] [--output=file.md] [--json=file.json] [--compare=YYYY-MM-DD] [--compare-days=28]');
|
||||
process.exit(2);
|
||||
}
|
||||
const until = arg('until', new Date().toISOString());
|
||||
const days = Number(arg('days', '7'));
|
||||
const since = new Date(at(until) - days * 86_400_000).toISOString();
|
||||
const git = (args) => execFileSync('git', args, { encoding: 'utf8' });
|
||||
const snapshot = fetchSnapshot({ repo, since, until, git });
|
||||
const report = buildReport({ since, until, ...snapshot });
|
||||
const git = (args) => execFileSync('git', args, { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
|
||||
const snapshot = fetchSnapshot({ repo, since, until, git, compare });
|
||||
// #728: jobs передаёт только CLI — `buildReport` без них job-минут не выдумывает.
|
||||
const report = buildReport({ since, until, ...snapshot, compare });
|
||||
const markdown = renderMarkdown(report);
|
||||
const output = arg('output');
|
||||
if (output) { mkdirSync(dirname(output), { recursive: true }); writeFileSync(output, markdown, 'utf8'); }
|
||||
|
||||
@@ -1,10 +1,20 @@
|
||||
// #637: еженедельный замер процесса — чистые функции над снимками GitHub.
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { dirname, join } from 'node:path';
|
||||
import {
|
||||
buildReport, issueMetrics, jobMinutes, pipelineMetrics, renderMarkdown, reviewDocNames, reviewRounds, runMetrics,
|
||||
NOT_RUN_CONFLICT_RE, NOT_RUN_VALIDATE_RE, TIMELINE_PAGE_CAP, TOKENS_NO_DATA, TRACKS_CUTOVER,
|
||||
compareCohorts, fetchSnapshot, isInfra, issueChanges, issueSegments, issueTrackMetrics, jobRuns, jobStage,
|
||||
readCommits, returnSignal, shipFindings, stageMinutes, tokenUsage, trackAt, trackPath, trackSection, volumeBucket,
|
||||
} from '../scripts/process-metrics.mjs';
|
||||
import { labelTrack } from '../scripts/process-track.mjs';
|
||||
import { commentFor } from '../scripts/merge-candidate.mjs';
|
||||
import { anchorBlock } from '../scripts/ship-review.mjs';
|
||||
import { PIPELINE_EVENTS } from '../scripts/wait-verdict.mjs';
|
||||
|
||||
const T = (h) => new Date(Date.UTC(2026, 8, 15, 0, Math.round(h * 60))).toISOString();
|
||||
const labeled = (name, h) => ({ event: 'labeled', label: { name }, created_at: T(h) });
|
||||
@@ -155,3 +165,401 @@ test('#682 reviewDocNames: живой каталог и архив legacy/review
|
||||
// Перенос r1 в архив не уменьшает число раундов задачи.
|
||||
assert.equal(reviewRounds(names).get('CODE:600'), 2);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// #728: эффект процесса по трекам.
|
||||
|
||||
const unlabeled = (name, h) => ({ event: 'unlabeled', label: { name }, created_at: T(h) });
|
||||
const commented = (body, h) => ({ event: 'commented', body, created_at: T(h) });
|
||||
const labeledAt = (name, iso) => ({ event: 'labeled', label: { name }, created_at: iso });
|
||||
const HOUR = 3_600_000;
|
||||
|
||||
test('#728 trackAt: трек на момент события и путь трека, прежние метки и инфраструктура (AC1)', () => {
|
||||
const events = [
|
||||
labeled('S1-new', 0), labeled('track:ship', 0), labeled('S5-ready', 1), labeled('S6-in-progress', 2),
|
||||
unlabeled('track:ship', 5), labeled('track:show', 5), labeled('S7-code-review', 6), labeled('S8-merged', 9),
|
||||
unlabeled('track:show', 10), labeled('track:ask', 10),
|
||||
];
|
||||
assert.equal(trackAt(events, T(4)), 'ship', 'до смены');
|
||||
assert.equal(trackAt(events, T(5)), 'ship', 'в сам момент смены — метки строго до него');
|
||||
assert.equal(trackAt(events, T(6)), 'show', 'после смены');
|
||||
assert.deepEqual(trackPath(events, { from: T(0), to: T(9) }), ['ship', 'show']);
|
||||
const row = issueTrackMetrics({ number: 701 }, events);
|
||||
assert.equal(row.track, 'show', 'трек задачи — на момент S8, смена после слияния не в счёт');
|
||||
assert.deepEqual(row.path, ['ship', 'show']);
|
||||
|
||||
// Прежние метки до 28.09 — по §5.1.
|
||||
const legacy = [labeledAt('S1-new', '2026-09-20T10:00:00Z'), labeledAt('small', '2026-09-20T10:00:00Z')];
|
||||
assert.equal(trackAt(legacy, '2026-09-21T00:00:00Z'), 'show', 'small → show');
|
||||
const bare = [labeledAt('S1-new', '2026-09-20T10:00:00Z')];
|
||||
assert.equal(trackAt(bare, '2026-09-21T00:00:00Z'), 'ask', 'без метки, продукт → ask');
|
||||
assert.equal(trackAt(bare, '2026-09-21T00:00:00Z', { infra: true }), 'show', 'без метки, инфраструктура → show');
|
||||
// Две трековые метки — как у process-track.mjs: строжайшая.
|
||||
const both = [labeled('track:ship', 0), labeled('track:ask', 0)];
|
||||
assert.equal(trackAt(both, T(1)), labelTrack({ labels: ['track:ship', 'track:ask'] }));
|
||||
assert.equal(trackAt(both, T(1)), 'ask');
|
||||
|
||||
// infra — ни одного файла класса A в коммитах задачи; Release:-коммит не в счёт.
|
||||
const commits = [
|
||||
{ sha: 'a'.repeat(40), body: 'x\n\nIssue: #801\n', issues: [801], files: [{ added: 5, deleted: 0, path: 'scripts/x.mjs' }] },
|
||||
{ sha: 'b'.repeat(40), body: 'x\n\nIssue: #802\n', issues: [802], files: [{ added: 5, deleted: 0, path: 'src/x.ts' }] },
|
||||
{ sha: 'c'.repeat(40), body: 'rel\n\nIssue: #801\nRelease: v1.0.0-beta.1\n', issues: [801], files: [{ added: 1, deleted: 1, path: 'custom_components/houseplan/manifest.json' }] },
|
||||
];
|
||||
const timelines = new Map([[801, [labeled('S6-in-progress', 0), labeled('S8-merged', 2)]], [802, [labeled('S6-in-progress', 0), labeled('S8-merged', 2)]]]);
|
||||
const report = buildReport({ since: T(0), until: T(48), issues: [{ number: 801 }, { number: 802 }], timelines, commits });
|
||||
const byNumber = new Map(report.tracks.rows.map((r) => [r.number, r]));
|
||||
assert.equal(byNumber.get(801).track, 'show', 'инфраструктура без метки → show');
|
||||
assert.equal(byNumber.get(802).track, 'ask', 'продукт без метки → ask');
|
||||
});
|
||||
|
||||
test('#728 issueSegments: отрезки по часам, blocked вычитается, сумма равна lead (AC2)', () => {
|
||||
const events = [
|
||||
labeled('S1-new', 0), labeled('S5-ready', 1), labeled('S6-in-progress', 2),
|
||||
labeled('blocked', 3), unlabeled('blocked', 4),
|
||||
labeled('S7-code-review', 5), labeled('S6-in-progress', 6), labeled('S7-code-review', 8), labeled('S8-merged', 9),
|
||||
];
|
||||
const seg = issueSegments(events);
|
||||
const inHours = Object.fromEntries(Object.entries(seg.segments).map(([k, v]) => [k, v / HOUR]));
|
||||
assert.deepEqual(inHours, { queue: 2, spec: 0, work: 2, review: 2, rework: 2, blocked: 1 });
|
||||
assert.equal(seg.leadMs, 9 * HOUR);
|
||||
assert.equal(Object.values(seg.segments).reduce((a, b) => a + b, 0), seg.leadMs, 'сумма отрезков = lead');
|
||||
assert.equal(seg.returns.length, 1);
|
||||
|
||||
// Повторная постановка S7 конвейером (#636, #706) — не возврат и не новый отрезок.
|
||||
const repeated = issueSegments([
|
||||
...events.slice(0, 6), labeled('S7-code-review', 5.5),
|
||||
events[6], events[7], unlabeled('S7-code-review', 8.5), labeled('S7-code-review', 8.5), events[8],
|
||||
]);
|
||||
assert.deepEqual(repeated.segments, seg.segments);
|
||||
assert.equal(repeated.returns.length, 1);
|
||||
// …и не сдвигает начало окна причины: вердикт до повторной постановки остаётся причиной.
|
||||
const verdictBefore = issueTrackMetrics({ number: 701 }, [
|
||||
...events.slice(0, 6), commented('Вердикт: жёлтый · Документ: docs/reviews/CODE-REVIEW-701-r1.md', 5.2),
|
||||
labeled('S7-code-review', 5.5), ...events.slice(6),
|
||||
]);
|
||||
assert.deepEqual(verdictBefore.returns.map((r) => r.reason), ['verdict-yellow']);
|
||||
|
||||
// Ревью ТЗ: S3 до первого возврата — spec, после S4 → S3 — rework.
|
||||
const spec = issueSegments([
|
||||
labeled('S3-spec', 0), labeled('S4-spec-review', 2), labeled('S3-spec', 3), labeled('S4-spec-review', 4),
|
||||
labeled('S5-ready', 5), labeled('S6-in-progress', 6), labeled('S7-code-review', 7), labeled('S8-merged', 8),
|
||||
]);
|
||||
assert.deepEqual(Object.fromEntries(Object.entries(spec.segments).map(([k, v]) => [k, v / HOUR])),
|
||||
{ queue: 1, spec: 2, work: 1, review: 3, rework: 1, blocked: 0 });
|
||||
assert.deepEqual(spec.returns.map((r) => r.stage), ['spec']);
|
||||
assert.equal(issueSegments([labeled('S6-in-progress', 0)]), null, 'без S8 — не в выборке');
|
||||
});
|
||||
|
||||
const NUM = 701;
|
||||
const VERDICT_YELLOW = `Вердикт: жёлтый · заход r1 · High: 0 · Medium: 2 · Документ: docs/reviews/CODE-REVIEW-${NUM}-r1.md`;
|
||||
const VERDICT_RED = `**Вердикт: красный** · заход r2 · High: 1 · Документ: docs/reviews/CODE-REVIEW-${NUM}-r2.md`;
|
||||
|
||||
/** Шаблоны «Ревью не запускалось» из `_process.yml`: снять экранирование и подставить `$kind`. */
|
||||
function notRunTemplates() {
|
||||
const workflow = readFileSync(new URL('../.github/workflows/_process.yml', import.meta.url), 'utf8');
|
||||
const templates = workflow.split('\n').map((line) => line.trim()).filter((line) => line.startsWith('**Ревью не запускалось:**'));
|
||||
const step = workflow.slice(workflow.indexOf('- name: Validate красный — вернуть автору без ревью'));
|
||||
const kinds = ['Validate', 'Validate с мутантами'];
|
||||
for (const kind of kinds) assert.ok(step.slice(0, 1500).includes(`kind="${kind}"`), `шаг Validate красный задаёт kind="${kind}"`);
|
||||
return templates.map((line) => kinds.map((kind) => line.replaceAll('\\`', '`').replaceAll('$kind', kind)
|
||||
.replaceAll('$BRANCH', 'issue/701-white-tile').replaceAll('$short', '1a2b3c4').replaceAll('$RESULT', 'failed')));
|
||||
}
|
||||
|
||||
test('#728 returnSignal: причины возврата на текстах конвейера (AC3)', () => {
|
||||
const sig = (body) => returnSignal(body, { stage: 'code', number: NUM });
|
||||
assert.equal(sig(VERDICT_YELLOW), 'verdict-yellow');
|
||||
assert.equal(sig(VERDICT_RED), 'verdict-red');
|
||||
assert.equal(sig(VERDICT_YELLOW.replace(`CODE-REVIEW-${NUM}`, 'CODE-REVIEW-702')), null, 'вердикт о чужом документе — не причина');
|
||||
assert.equal(sig(`Вердикт: зелёный · заход r1 · Документ: docs/reviews/CODE-REVIEW-${NUM}-r1.md`), null, 'зелёный — не причина возврата');
|
||||
assert.equal(sig(commentFor('reject-stale', { material: 'a'.repeat(40), actual: 'b'.repeat(40) })), 'merge');
|
||||
assert.equal(sig(commentFor('conflict', { branch: 'issue/701-x' })), 'merge');
|
||||
assert.ok(PIPELINE_EVENTS.find((e) => e.kind === 'stale').re.test(commentFor('reject-stale', {})), 'текст под константу конвейера');
|
||||
assert.equal(sig('**Ревью не запускалось:** что-то третье, о чём отчёт не знает.'), 'unknown');
|
||||
const refused = commentFor('push-refused-workflow', {
|
||||
stage: 'rebase', candidate: 'c'.repeat(40), branch: 'issue/701-x', refusal: { files: ['.github/workflows/x.yml'] },
|
||||
});
|
||||
assert.match(refused, /^\*\*Ревью не запускалось: кандидат меняет workflow-файл/);
|
||||
assert.equal(sig(refused), null, 'отказ push по праву на workflow (#705) — без признака, возврат уйдёт в unknown');
|
||||
assert.equal(sig('Текст.\n\n<!-- hp:route reclassify criterion=undocumented -->'), 'reclassify');
|
||||
assert.equal(sig('Текст.\n\n<!-- hp:route owner-question criterion=undocumented -->'), 'owner-question');
|
||||
assert.equal(sig('Пока шло ревью, `dev` продвинулся на 2 коммит(ов).'), null);
|
||||
assert.equal(NOT_RUN_VALIDATE_RE.flags.includes('m') && NOT_RUN_CONFLICT_RE.flags.includes('m'), true);
|
||||
});
|
||||
|
||||
test('#728 контракт: шаблоны «Ревью не запускалось» _process.yml дают conflict и validate-red (AC3)', () => {
|
||||
const templates = notRunTemplates();
|
||||
assert.equal(templates.length, 2, 'шаблонов «Ревью не запускалось:» в _process.yml ровно два');
|
||||
const reasons = templates.map((variants) => [...new Set(variants.map((text) => returnSignal(text, { stage: 'code', number: NUM })))]);
|
||||
assert.deepEqual(reasons.map((r) => r.join(',')).sort(), ['conflict', 'validate-red'],
|
||||
'один шаблон — conflict, другой — validate-red при обоих $kind');
|
||||
for (const variants of templates) {
|
||||
for (const text of variants) assert.ok(PIPELINE_EVENTS.find((e) => e.kind === 'conflict').re.test(text), 'общий префикс — под константой PIPELINE_EVENTS');
|
||||
}
|
||||
});
|
||||
|
||||
test('#728 returnReason: последний комментарий с признаком, возврат без комментария — unknown, трек своего момента (AC3)', () => {
|
||||
const issue = { number: NUM };
|
||||
const cycle = (h, comment) => [
|
||||
labeled('S7-code-review', h), ...(comment ? [commented(comment, h + 0.5)] : []), labeled('S6-in-progress', h + 0.5),
|
||||
];
|
||||
const templates = notRunTemplates();
|
||||
const conflict = templates.find((variants) => variants[0].includes(' ветка '));
|
||||
const validate = templates.find((variants) => variants !== conflict);
|
||||
const events = [
|
||||
labeled('S1-new', 0), labeled('track:ship', 0), labeled('S6-in-progress', 1),
|
||||
...cycle(2, VERDICT_YELLOW),
|
||||
...cycle(3, VERDICT_RED),
|
||||
...cycle(4, validate[0]),
|
||||
...cycle(5, validate[1]),
|
||||
unlabeled('track:ship', 5.8), labeled('track:show', 5.8),
|
||||
...cycle(6, conflict[0]),
|
||||
...cycle(7, commentFor('reject-stale', {})),
|
||||
// Комментарий без признака после вердикта не перекрывает причину.
|
||||
labeled('S7-code-review', 8), commented(VERDICT_YELLOW, 8.2), commented('Пока шло ревью, `dev` продвинулся на 1 коммит(ов).', 8.3), labeled('S6-in-progress', 8.5),
|
||||
...cycle(9, null),
|
||||
...cycle(10, VERDICT_YELLOW.replace(`CODE-REVIEW-${NUM}`, 'CODE-REVIEW-702')),
|
||||
...cycle(11, '**Ревью не запускалось:** иное продолжение.'),
|
||||
...cycle(12, commentFor('push-refused-workflow', { stage: 'rebase', candidate: 'c'.repeat(40), branch: 'b' })),
|
||||
labeled('S7-code-review', 13), commented('Ревью show: решать есть что.\n<!-- hp:route owner-question criterion=undocumented -->', 13.5),
|
||||
labeled('blocked', 13.5), labeled('S6-in-progress', 13.5), unlabeled('blocked', 13.8),
|
||||
labeled('S7-code-review', 14), commented('Трек повышен.\n<!-- hp:route reclassify criterion=undocumented -->', 14.5),
|
||||
labeled('S3-spec', 14.5), unlabeled('track:show', 14.5), labeled('track:ask', 14.5),
|
||||
labeled('S4-spec-review', 15), commented(`Вердикт: красный · Документ: docs/reviews/SPEC-REVIEW-${NUM}-r1.md`, 15.5), labeled('S3-spec', 15.5),
|
||||
labeled('S4-spec-review', 16), labeled('S5-ready', 16.5), labeled('S6-in-progress', 17), labeled('S7-code-review', 18), labeled('S8-merged', 19),
|
||||
];
|
||||
const row = issueTrackMetrics(issue, events);
|
||||
assert.deepEqual(row.returns.map((r) => r.reason), [
|
||||
'verdict-yellow', 'verdict-red', 'validate-red', 'validate-red', 'conflict', 'merge', 'verdict-yellow',
|
||||
'unknown', 'unknown', 'unknown', 'unknown', 'owner-question', 'reclassify', 'verdict-red',
|
||||
]);
|
||||
assert.deepEqual(row.returns.map((r) => r.track), [
|
||||
'ship', 'ship', 'ship', 'ship', 'show', 'show', 'show', 'show', 'show', 'show', 'show', 'show', 'show', 'ask',
|
||||
], 'возврат — по треку своего момента; reclassify — на треке, где шло ревью');
|
||||
assert.deepEqual(row.path, ['ship', 'show', 'ask']);
|
||||
assert.equal(row.track, 'ask');
|
||||
const section = trackSection([row]);
|
||||
const ship = section.events.find((e) => e.track === 'ship');
|
||||
assert.deepEqual([ship.returns, ship.reasons['verdict-yellow'], ship.reasons['validate-red']], [4, 1, 2]);
|
||||
assert.equal(section.events.find((e) => e.track === 'show').reasons.unknown, 4);
|
||||
// Раунды — объявления вердикта этапа, по треку и блокирующие/зелёные.
|
||||
assert.deepEqual([ship.rounds.code.blocking, ship.rounds.code.green], [2, 0]);
|
||||
assert.deepEqual(section.events.find((e) => e.track === 'ask').rounds.spec, { blocking: 1, green: 0 });
|
||||
});
|
||||
|
||||
test('#728 shipFindings: находки пакетного ревью ship по машинному блоку, архив тоже читается (AC4)', () => {
|
||||
const doc = (tag, issues, high, medium, low) => anchorBlock({ tag, candidate: 'c'.repeat(40), issues, high, medium, low });
|
||||
const reviewDocs = [
|
||||
{ path: 'docs/reviews/SHIP-REVIEW-v1.79.0-beta.2.md', text: `# Пакетное ревью\n\n${doc('v1.79.0-beta.2', [701, 702], 0, 1, 2)}` },
|
||||
{ path: 'legacy/reviews/v1.78.0/SHIP-REVIEW-v1.78.0-beta.9.md', text: doc('v1.78.0-beta.9', [703], 1, 0, 0) },
|
||||
{ path: 'docs/reviews/CODE-REVIEW-701-r1.md', text: doc('v1.79.0-beta.2', [701], 9, 9, 9) },
|
||||
];
|
||||
const { byIssue } = shipFindings(reviewDocs);
|
||||
assert.deepEqual(byIssue.get(701), { high: 0, medium: 1, low: 2, docs: ['docs/reviews/SHIP-REVIEW-v1.79.0-beta.2.md'] });
|
||||
assert.deepEqual([byIssue.get(702).medium, byIssue.get(702).low], [1, 2]);
|
||||
assert.equal(byIssue.get(703).high, 1, 'документ из legacy/reviews/ читается');
|
||||
assert.equal(byIssue.has(704), false, 'задачи нет в блоке — находок нет');
|
||||
|
||||
const shipped = (n) => [labeled('S1-new', 0), labeled('track:ship', 0), labeled('S6-in-progress', 1), labeled('S7-code-review', 2), labeled('S8-merged', 3)];
|
||||
const timelines = new Map([701, 702, 704].map((n) => [n, shipped(n)]));
|
||||
const report = buildReport({ since: T(0), until: T(48), issues: [701, 702, 704].map((number) => ({ number })), timelines, reviewDocs });
|
||||
const rows = new Map(report.tracks.rows.map((r) => [r.number, r]));
|
||||
assert.deepEqual([rows.get(701).ship.medium, rows.get(701).ship.low], [1, 2]);
|
||||
assert.deepEqual(rows.get(704).ship, { high: 0, medium: 0, low: 0, docs: [] });
|
||||
const ship = report.tracks.byTrack.find((r) => r.track === 'ship').ship;
|
||||
assert.deepEqual(ship, { issues: 3, covered: 2, docs: 1, high: 0, medium: 1, low: 2 }, 'документ на две задачи — один раз');
|
||||
assert.match(renderMarkdown(report), /\| ship \| 3 \|[^\n]*покрыто 2 из 3, документов 1: High 0 · Medium 1 · Low 2 \|/);
|
||||
});
|
||||
|
||||
const jobsRun = (id, over) => ({ id, name: 'Ревью-конвейер', event: 'issues', conclusion: 'success', run_started_at: T(10), updated_at: T(11), ...over });
|
||||
const job = (name, startH, endH) => ({ name, started_at: T(startH), completed_at: T(endH) });
|
||||
|
||||
test('#728 stageMinutes: job-минуты по стадиям и треку, Validate по событию, усечение, нет данных (AC5)', () => {
|
||||
const runs = [
|
||||
jobsRun(1, { display_title: 'process #701 · S7-code-review · x' }),
|
||||
jobsRun(2, { display_title: 'process #701 · bug · x', conclusion: 'skipped' }),
|
||||
jobsRun(3, { name: 'Проверка (CI)', display_title: 'feat: x', event: 'push' }),
|
||||
jobsRun(4, { name: 'Проверка (CI)', display_title: 'feat: x', event: 'workflow_dispatch' }),
|
||||
];
|
||||
const jobsByRun = new Map([
|
||||
[1, [
|
||||
job('dev / Страж: ребейз на dev и предпосылки ревью', 10, 10.1),
|
||||
job('dev / Ревью: материал и deterministic gates', 10.1, 10.3),
|
||||
job('dev / Ревью: работа модели', 10.3, 10.8),
|
||||
job('dev / Ревью: публикация и интеграция', 10.8, 10.9),
|
||||
]],
|
||||
[3, [job('Фронтенд: типы', 10, 10.25), job('Мутанты по диффу (1/6): x', 10, 10.5)]],
|
||||
[4, [job('Фронтенд: типы', 10, 11)]],
|
||||
]);
|
||||
assert.deepEqual(jobRuns(runs).selected.map((r) => r.id), [1, 3, 4], 'skipped без jobs');
|
||||
const timelines = new Map([[701, [labeled('S1-new', 0), labeled('track:ship', 0), labeled('S6-in-progress', 1), labeled('S8-merged', 20)]]]);
|
||||
const report = buildReport({ since: T(0), until: T(48), issues: [{ number: 701 }], timelines, runs, jobsByRun });
|
||||
assert.deepEqual(report.stages.process.stages, { guard: 6, prepare: 12, model: 30, integrate: 6, other: 0 });
|
||||
assert.deepEqual(report.stages.process.byTrack, { ship: { guard: 6, prepare: 12, model: 30, integrate: 6, other: 0 } });
|
||||
assert.deepEqual(report.stages.validate, { runs: 2, minutes: 105, byEvent: { push: 45, workflow_dispatch: 60 } });
|
||||
assert.equal(report.stages.truncated, null);
|
||||
const md = renderMarkdown(report);
|
||||
assert.match(md, /### Job-минуты по стадиям[\s\S]*\| model \| 30 \| 30 \|/);
|
||||
assert.match(md, /Validate: \*\*105\*\* мин за 2 прогонов \(push 45, workflow_dispatch 60\)/);
|
||||
assert.match(md, /Job-минуты: \*\*159\*\*, из них «Мутанты» 30/, 'прежняя строка снова печатается');
|
||||
|
||||
// 601-й прогон — усечено.
|
||||
const many = Array.from({ length: 601 }, (_, k) => jobsRun(100 + k, { name: 'Проверка (CI)', display_title: 'x', event: 'push' }));
|
||||
assert.equal(jobRuns(many).selected.length, 600);
|
||||
const capped = stageMinutes({ runs: many, jobsByRun: new Map(many.map((r) => [r.id, []])) });
|
||||
assert.deepEqual(capped.truncated, { fetched: 600, total: 601 });
|
||||
assert.match(renderMarkdown(buildReport({ since: T(0), until: T(48), runs: many, jobsByRun: new Map() })), /усечено: 600 из 601 прогонов/);
|
||||
|
||||
// Jobs недоступны (403, истёк срок) — «нет данных», а не ноль.
|
||||
const gone = buildReport({ since: T(0), until: T(48), issues: [{ number: 701 }], timelines, runs, jobsByRun: new Map([[1, null], [3, null], [4, null]]) });
|
||||
assert.equal(gone.stages.process, null);
|
||||
assert.equal(gone.stages.validate, null);
|
||||
assert.equal(gone.stages.unavailable, 3);
|
||||
const goneMd = renderMarkdown(gone);
|
||||
assert.match(goneMd, /Конвейер: нет данных/);
|
||||
assert.match(goneMd, /Validate: нет данных/);
|
||||
assert.doesNotMatch(goneMd.slice(goneMd.indexOf('### Job-минуты по стадиям')), /\| guard \| 0/);
|
||||
});
|
||||
|
||||
test('#728 контракт: имена job _process.yml дают четыре стадии конвейера (AC5)', () => {
|
||||
const workflow = readFileSync(new URL('../.github/workflows/_process.yml', import.meta.url), 'utf8');
|
||||
const names = [...workflow.matchAll(/^ {4}name: "([^"]+)"$/gm)].map((m) => m[1]);
|
||||
assert.deepEqual(names.map((name) => jobStage(`dev / ${name}`)), ['guard', 'prepare', 'model', 'integrate']);
|
||||
});
|
||||
|
||||
test('#728 tokenUsage: без строки расхода — «нет данных», чисел токенов нет (AC6)', () => {
|
||||
const report = buildReport({ since: T(0), until: T(48), reviewDocs: [{ path: 'docs/reviews/CODE-REVIEW-701-r1.md', text: '# Ревью\n\nВердикт: зелёный' }] });
|
||||
assert.equal(report.tokens, null);
|
||||
const md = renderMarkdown(report);
|
||||
assert.ok(md.includes(TOKENS_NO_DATA));
|
||||
assert.equal(TOKENS_NO_DATA, 'Токены: нет данных (конвейер не записывает расход модели)');
|
||||
const section = md.slice(md.indexOf('### Токены'), md.indexOf('###', md.indexOf('### Токены') + 3));
|
||||
assert.doesNotMatch(section, /\d/, 'ни оценок, ни пересчётов из минут');
|
||||
const recorded = tokenUsage([{ path: 'docs/reviews/CODE-REVIEW-701-r1.md', text: '<!-- hp:usage input_tokens=1200 output_tokens=300 -->' }]);
|
||||
assert.deepEqual(recorded, { docs: 1, totals: { input_tokens: 1200, output_tokens: 300 } }, 'когда строка появится (issue F), она читается');
|
||||
});
|
||||
|
||||
test('#728 сравнение: объём из git без Release:, dist/** и docs/reviews/**, корзины и «мало данных» (AC7)', (t) => {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'hp-728-'));
|
||||
t.after(() => rmSync(dir, { recursive: true, force: true }));
|
||||
const git = (...args) => {
|
||||
const r = spawnSync('git', args, { cwd: dir, encoding: 'utf8' });
|
||||
assert.equal(r.status, 0, r.stderr);
|
||||
return r.stdout;
|
||||
};
|
||||
git('init', '-q', '-b', 'dev');
|
||||
git('config', 'user.email', 't@t'); git('config', 'user.name', 't');
|
||||
git('config', 'core.hooksPath', '/dev/null');
|
||||
const write = (path, lines) => { mkdirSync(join(dir, dirname(path)), { recursive: true }); writeFileSync(join(dir, path), `${Array.from({ length: lines }, (_, k) => `l${k}`).join('\n')}\n`); };
|
||||
write('src/a.ts', 10); write('dist/houseplan-card.js', 500); write('docs/reviews/CODE-REVIEW-701-r1.md', 40);
|
||||
git('add', '.'); git('commit', '-q', '-m', 'feat: a (#701)\n\nIssue: #701\nUser-Visible: no');
|
||||
write('src/b.ts', 300);
|
||||
git('add', '.'); git('commit', '-q', '-m', 'Release v1.0.0-beta.1 candidate\n\nIssue: #701\nRelease: v1.0.0-beta.1');
|
||||
write('scripts/x.mjs', 25);
|
||||
git('add', '.'); git('commit', '-q', '-m', 'test: x (#702)\n\nIssue: #702');
|
||||
const commits = readCommits((args) => git(...args), { ref: 'HEAD', since: '2000-01-01' });
|
||||
assert.equal(commits.length, 3);
|
||||
const changes = issueChanges(commits);
|
||||
assert.equal(changes.get(701).lines, 10, 'без Release:-коммита, без dist/** и без docs/reviews/**');
|
||||
assert.equal(changes.get(702).lines, 25);
|
||||
assert.equal(isInfra(changes.get(701)), false);
|
||||
assert.equal(isInfra(changes.get(702)), true);
|
||||
|
||||
assert.deepEqual([0, 30, 31, 200, 201, 1000, 1001].map(volumeBucket), ['≤30', '≤30', '31–200', '31–200', '201–1000', '201–1000', '>1000']);
|
||||
assert.equal(volumeBucket(null), null);
|
||||
|
||||
const row = (number, iso, track, volume, leadH, returns = 0) => ({
|
||||
number, s8At: Date.parse(iso), track, volume, bucket: volumeBucket(volume), truncated: false, leadMs: leadH * HOUR,
|
||||
segments: { queue: 0, spec: 0, work: leadH * HOUR / 2, review: leadH * HOUR / 2, rework: 0, blocked: 0 },
|
||||
returns: Array.from({ length: returns }, () => ({ reason: 'verdict-yellow' })),
|
||||
});
|
||||
const rows = [
|
||||
row(1, '2026-09-01T00:00:00Z', 'show', 10, 10, 1), row(2, '2026-09-10T00:00:00Z', 'show', 20, 12, 1), row(3, '2026-09-27T23:00:00Z', 'show', 30, 14, 0),
|
||||
row(4, '2026-09-28T00:00:00Z', 'show', 5, 4), row(5, '2026-09-29T00:00:00Z', 'show', 6, 6), row(6, '2026-10-01T00:00:00Z', 'show', 7, 8),
|
||||
row(7, '2026-09-05T00:00:00Z', 'ask', 150, 40), row(8, '2026-09-06T00:00:00Z', 'ask', 160, 50),
|
||||
row(9, '2026-09-30T00:00:00Z', 'ask', 170, 20), row(10, '2026-10-02T00:00:00Z', 'ask', 180, 21), row(11, '2026-10-03T00:00:00Z', 'ask', 190, 22),
|
||||
row(12, '2026-08-30T23:59:00Z', 'show', 10, 99), row(13, '2026-10-04T00:00:00Z', 'show', 10, 99),
|
||||
{ ...row(14, '2026-09-20T00:00:00Z', 'show', null, 1), bucket: null },
|
||||
];
|
||||
const compare = compareCohorts(rows, { cutover: '2026-09-28', days: 28, until: '2026-10-04T00:00:00Z' });
|
||||
const show = compare.cohorts.find((c) => c.key === 'show · ≤30');
|
||||
assert.deepEqual([show.before.n, show.after.n, show.enough], [3, 3, true], '#12 до окна и #13 в until не входят');
|
||||
assert.deepEqual([show.before.lead, show.after.lead, show.diff.lead], [12, 6, -6]);
|
||||
assert.deepEqual([show.before.returns, show.after.returns], [0.67, 0]);
|
||||
const ask = compare.cohorts.find((c) => c.key === 'ask · 31–200');
|
||||
assert.deepEqual([ask.before.n, ask.after.n, ask.enough, ask.diff], [2, 3, false, null]);
|
||||
assert.deepEqual(compare.noCommits, [14]);
|
||||
const md = renderMarkdown({ ...buildReport({ since: T(0), until: T(1) }), compare });
|
||||
assert.match(md, /\| show · ≤30 \| 3 \| 3 \| 12 → 6 \(-6\) \|/);
|
||||
assert.match(md, /\| ask · 31–200 \| 2 \| 3 \| мало данных \|/);
|
||||
assert.match(md, /Без коммитов с трейлером[^\n]*#14/);
|
||||
});
|
||||
|
||||
test('#728 renderMarkdown: новые разделы после прежних, JSON несёт те же поля, buildReport без jobs (AC8)', () => {
|
||||
const report = buildReport({ since: T(0), until: T(48), issues: [{ number: 701, closed_at: T(30), state_reason: 'completed' }],
|
||||
timelines: new Map([[701, [labeled('S1-new', 0), labeled('S7-code-review', 2), labeled('S8-merged', 3)]]]) });
|
||||
assert.equal(report.jobs, null);
|
||||
assert.equal(report.stages, null, 'jobs передаёт только CLI');
|
||||
const md = renderMarkdown(report);
|
||||
const order = ['</details>', '### По трекам', '### Job-минуты по стадиям', '### Токены', `### До и после ${TRACKS_CUTOVER}`].map((s) => md.indexOf(s));
|
||||
assert.ok(order.every((i) => i > 0) && order.every((i, k) => k === 0 || i > order[k - 1]), `порядок разделов: ${order}`);
|
||||
assert.match(md, /Нет данных: jobs прогонов не запрашивались/);
|
||||
const json = JSON.parse(JSON.stringify(report));
|
||||
for (const key of ['tracks', 'stages', 'tokens', 'compare']) assert.ok(key in json, key);
|
||||
assert.equal(json.tracks.rows[0].track, 'ask');
|
||||
});
|
||||
|
||||
test('#728 workflow: полная история и потолок 30 минут', () => {
|
||||
const wf = readFileSync(new URL('../.github/workflows/_process-metrics.yml', import.meta.url), 'utf8');
|
||||
const metrics = wf.slice(wf.indexOf('\n metrics:\n'));
|
||||
assert.ok(metrics.length > 1, 'job metrics');
|
||||
const head = metrics.slice(0, metrics.indexOf('\n steps:'));
|
||||
assert.match(head, /^ {4}timeout-minutes: 30$/m);
|
||||
assert.match(metrics, /- uses: actions\/checkout@[0-9a-f]{40}[^\n]*\n {8}with:\n(?: {10}[^\n]*\n)*? {10}fetch-depth: 0\n/);
|
||||
assert.equal([...wf.matchAll(/fetch-depth:/g)].length, 1, 'другой строки fetch-depth: в файле нет');
|
||||
});
|
||||
|
||||
test('#728 fetchSnapshot: state=all, таймлайн до 10 страниц, jobs недоступны — null', () => {
|
||||
const calls = [];
|
||||
const full = Array.from({ length: 100 }, () => labeled('bug', 0));
|
||||
const gh = (args) => {
|
||||
const path = args[1];
|
||||
calls.push(path);
|
||||
if (path.startsWith('repos/o/r/issues?')) {
|
||||
return path.includes('page=1') ? [
|
||||
{ number: 701, state: 'open', labels: [{ name: 'S8-merged' }] },
|
||||
{ number: 702, state: 'closed', closed_at: T(30), state_reason: 'completed', labels: [] },
|
||||
{ number: 703, state: 'open', labels: [{ name: 'S6-in-progress' }] },
|
||||
{ number: 704, pull_request: {}, state: 'open', labels: [] },
|
||||
] : [];
|
||||
}
|
||||
if (path.startsWith('repos/o/r/actions/runs?')) {
|
||||
return { workflow_runs: [
|
||||
jobsRun(1, { display_title: 'process #703 · S7-code-review · x' }),
|
||||
jobsRun(2, { name: 'Проверка (CI)', display_title: 'x', event: 'push' }),
|
||||
] };
|
||||
}
|
||||
if (path === 'repos/o/r/actions/runs/1/jobs?per_page=100&page=1') return { jobs: [job('dev / Ревью: работа модели', 10, 10.5)] };
|
||||
if (path.startsWith('repos/o/r/actions/runs/2/jobs')) throw new Error('HTTP 410');
|
||||
if (path.startsWith('repos/o/r/issues/701/timeline')) return full;
|
||||
if (path.startsWith('repos/o/r/issues/')) return [labeled('S1-new', 0)];
|
||||
throw new Error(`unexpected ${path}`);
|
||||
};
|
||||
const git = (args) => {
|
||||
if (args[0] === 'ls-tree') return 'docs/reviews/SHIP-REVIEW-v1.79.0-beta.2.md\ndocs/reviews/CODE-REVIEW-701-r1.md\n';
|
||||
if (args[0] === 'grep') throw new Error('exit 1');
|
||||
if (args[0] === 'show') return 'ship doc';
|
||||
if (args[0] === 'rev-parse') return 'f'.repeat(40);
|
||||
if (args[0] === 'log') return `\x1e${'a'.repeat(40)}\x1f2026-09-30T00:00:00Z\x1fx\n\nIssue: #701\n\x1f\n3\t1\tsrc/a.ts\n`;
|
||||
throw new Error(`git ${args.join(' ')}`);
|
||||
};
|
||||
const snap = fetchSnapshot({ repo: 'o/r', since: T(0), until: T(48), gh, git });
|
||||
assert.ok(calls[0].includes('state=all') && calls[0].includes(`since=${encodeURIComponent('2026-08-31T00:00:00.000Z')}`), calls[0]);
|
||||
assert.deepEqual(snap.issues.map((i) => i.number), [702], 'прежняя выборка — закрытые в окне');
|
||||
assert.deepEqual(snap.allIssues.map((i) => i.number), [701, 702, 703], 'S8, закрытые и задачи прогонов конвейера');
|
||||
assert.equal(calls.filter((c) => c.startsWith('repos/o/r/issues/701/timeline')).length, TIMELINE_PAGE_CAP);
|
||||
assert.deepEqual([...snap.timelineTruncated], [701]);
|
||||
assert.equal(snap.jobsByRun.get(1).length, 1);
|
||||
assert.equal(snap.jobsByRun.get(2), null);
|
||||
assert.deepEqual(snap.reviewDocs, [{ path: 'docs/reviews/SHIP-REVIEW-v1.79.0-beta.2.md', text: 'ship doc' }]);
|
||||
assert.equal(issueChanges(snap.commits).get(701).lines, 4);
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user