@application-kit/acceptance 0.0.0-stage → 0.1.0

package/dist/esm/scenarios/coverage-data.js

@@ -0,0 +1,109 @@
+import path from 'node:path';
+import { markPending, marks, markTodo } from './config.js';
+import { parseFeature } from './gherkin.js';
+import { git } from './git.js';
+import { compareText, roundTenth } from './python-text.js';
+import { blobUrl, webUrl } from './remote.js';
+import { linkToken } from './task-links.js';
+export const uncoveredOrder = ['off-run', 'todo-only', 'no-scenario'];
+export const uncoveredLabels = {
+    'no-scenario': 'без сценария',
+    'off-run': 'вне прогона',
+    'todo-only': `только долг @${markTodo}`,
+};
+const uncoveredOf = {
+    'без сценария': 'no-scenario',
+    'все сняты': 'no-scenario',
+    'с тестом': 'off-run',
+    'только долг': 'todo-only',
+};
+const repositoryRoot = '.';
+export const liveScenarios = (ids, scenarios) => ids
+    .filter((id) => !scenarios.removed.has(id))
+    .flatMap((id) => scenarios.ids.get(id)?.slice(0, 1) ?? []);
+const isInRun = (story, scenarios) => liveScenarios(story.ids, scenarios).some((scenario) => scenario.tags.every((tag) => !marks.includes(tag)));
+const uncoveredStory = (item, location, story) => ({
+    file: story.file,
+    project: item.project.name,
+    scenarios: story.ids,
+    state: uncoveredOf[story.state],
+    story: story.key,
+    url: blobUrl(location, story.file),
+});
+const uncoveredStories = async (item, scenarios) => {
+    const location = { commit: item.project.commit, web: await webUrl(scenarios.cwd, item.project.repo) };
+    return item.stories
+        .filter((story) => story.state !== 'все сняты' && !isInRun(story, scenarios))
+        .map((story) => uncoveredStory(item, location, story));
+};
+const stateCounts = (uncovered) => {
+    const count = (state) => uncovered.filter((story) => story.state === state).length;
+    return { 'no-scenario': count('no-scenario'), 'off-run': count('off-run'), 'todo-only': count('todo-only') };
+};
+const shareOf = (covered, denominator) => (denominator === 0 ? undefined : roundTenth((100 * covered) / denominator));
+const projectOf = (item, uncovered) => {
+    const { counts } = item;
+    const denominator = counts.e2e - counts['все сняты'];
+    const covered = denominator - uncovered.length;
+    return {
+        allRemoved: counts['все сняты'],
+        closed: item.closed,
+        codeTests: counts['code-tests'],
+        commit: item.project.commit ?? '',
+        covered,
+        denominator,
+        e2e: counts.e2e,
+        none: counts.none,
+        project: item.project.name,
+        revision: item.project.revision ?? '',
+        share: shareOf(covered, denominator),
+        unclassified: counts['без класса'],
+        uncovered: stateCounts(uncovered),
+    };
+};
+export const coverageOf = async (classified, scenarios) => {
+    const rows = await Promise.all(classified.map(async (item) => ({
+        item,
+        uncovered: await uncoveredStories(item, scenarios),
+    })));
+    return {
+        projects: rows.map(({ item, uncovered }) => projectOf(item, uncovered)),
+        uncovered: rows.flatMap(({ uncovered }) => uncovered),
+    };
+};
+const referrerOf = (row) => ({
+    file: row.file,
+    line: row.line,
+    project: row.project,
+    status: row.status,
+});
+const referrersOf = (rows) => {
+    const found = rows.flatMap((row) => [...row.text.matchAll(linkToken)]
+        .map((match) => ({ row, tag: match[0].slice(1) })));
+    const grouped = Map.groupBy(found, ({ tag }) => tag);
+    return new Map([...grouped].map(([tag, items]) => [tag, items.map(({ row }) => referrerOf(row))]));
+};
+const pendingIds = (context, scenario) => scenario.tags
+    .filter((tag) => context.scenarios.config.id.test(tag))
+    .slice(0, 1)
+    .filter((id) => scenario.tags.includes(markPending) && !context.scenarios.removed.has(id));
+const pendingOf = (context, scenario) => {
+    const { file, location, referrers } = context;
+    const { line, title } = scenario;
+    return pendingIds(context, scenario)
+        .map((id) => ({ file, id, line, stories: referrers.get(id) ?? [], title, url: blobUrl(location, file, line) }));
+};
+const headLocation = async (scenarios) => {
+    const head = await git(scenarios.cwd, repositoryRoot, ['rev-parse', 'HEAD']);
+    return { commit: (head ?? '').trim(), web: await webUrl(scenarios.cwd, repositoryRoot) };
+};
+export const pendingScenarios = async (scenarios, files, rows) => {
+    const referrers = referrersOf(rows);
+    const location = await headLocation(scenarios);
+    const pending = [...files].flatMap(([raw, text]) => {
+        const file = path.posix.normalize(raw);
+        const context = { file, location, referrers, scenarios };
+        return parseFeature(text, file).flatMap((scenario) => pendingOf(context, scenario));
+    });
+    return pending.toSorted((left, right) => compareText(left.id, right.id));
+};

package/dist/esm/scenarios/coverage-json.d.ts

@@ -0,0 +1,2 @@
+import type { CoverageDataInterface } from './coverage.js';
+export declare const coverageJson: (data: CoverageDataInterface) => string;

package/dist/esm/scenarios/coverage-json.js

@@ -0,0 +1,90 @@
+import { uncoveredOrder } from './coverage-data.js';
+class PyFloat {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+const ordered = (fields) => Object.fromEntries(fields);
+const projectJson = (item) => ordered([
+    ['project', item.project],
+    ['ref', item.revision],
+    ['commit', item.commit],
+    ['closed', item.closed],
+    ['e2e', item.e2e],
+    ['all_removed', item.allRemoved],
+    ['code_tests', item.codeTests],
+    ['none', item.none],
+    ['unclassified', item.unclassified],
+    ['denominator', item.denominator],
+    ['covered', item.covered],
+    ['share', item.share === undefined ? null : new PyFloat(item.share)],
+    ['uncovered', ordered(uncoveredOrder.map((state) => [state, item.uncovered[state]]))],
+]);
+const uncoveredJson = (story) => ordered([
+    ['project', story.project],
+    ['story', story.story],
+    ['path', story.file],
+    ['url', story.url ?? null],
+    ['state', story.state],
+    ['scenarios', story.scenarios],
+]);
+const openJson = (story) => ordered([
+    ['project', story.project],
+    ['story', story.story],
+    ['status', story.status],
+    ['group', story.group],
+    ['path', story.file ?? null],
+    ['url', story.url ?? null],
+    ['scenarios', story.scenarios],
+]);
+const referrerJson = (story) => ordered([
+    ['project', story.project],
+    ['path', story.file],
+    ['line', story.line],
+    ['status', story.status],
+]);
+const pendingJson = (scenario) => ordered([
+    ['id', scenario.id],
+    ['title', scenario.title],
+    ['file', scenario.file],
+    ['line', scenario.line],
+    ['url', scenario.url ?? null],
+    ['stories', scenario.stories.map((story) => referrerJson(story))],
+]);
+const removedJson = (row) => ordered([
+    ['id', row.id],
+    ['date', row.date],
+    ['reason', row.reason],
+    ['story', row.story],
+    ['replaced_by', row.replacedBy],
+    ['commit', row.commit],
+]);
+const pythonShape = (data) => ordered([
+    ['date', data.date],
+    ['period', ordered([['since', data.period.since], ['until', data.period.until]])],
+    ['projects', data.projects.map((item) => projectJson(item))],
+    ['uncovered', data.uncovered.map((story) => uncoveredJson(story))],
+    ['open', data.open.map((story) => openJson(story))],
+    ['pending', data.pending.map((scenario) => pendingJson(scenario))],
+    ['removed', data.removed.map((row) => removedJson(row))],
+    ['notes', data.notes],
+    ['defects', data.defects],
+]);
+const isPlainObject = (value) => {
+    const isObject = typeof value === 'object' && value !== null;
+    return isObject && !Array.isArray(value) && !(value instanceof PyFloat);
+};
+const floatText = (value) => (Number.isSafeInteger(value) ? `${value}.0` : String(value));
+const block = (open, close, entries, indent) => (entries.length === 0
+    ? `${open}${close}`
+    : `${open}\n${entries.join(',\n')}\n${indent}${close}`);
+const scalarJson = (value) => (value instanceof PyFloat ? floatText(value.value) : JSON.stringify(value));
+const dump = (value, indent) => {
+    const inner = `${indent}  `;
+    if (Array.isArray(value)) {
+        return block('[', ']', value.map((item) => `${inner}${dump(item, inner)}`), indent);
+    }
+    return isPlainObject(value) ? block('{', '}', Object.entries(value).map(([key, item]) => `${inner}${JSON.stringify(key)}: ${dump(item, inner)}`), indent) : scalarJson(value);
+};
+export const coverageJson = (data) => `${dump(pythonShape(data), '')}\n`;

package/dist/esm/scenarios/coverage-open.d.ts

@@ -0,0 +1,16 @@
+import type { ClassifiedInterface } from './classes.js';
+import type { ScenariosInterface } from './classify.js';
+export type OpenGroupType = (typeof openOrder)[number];
+export interface OpenRowInterface {
+    readonly file: string | undefined;
+    readonly group: OpenGroupType;
+    readonly project: string;
+    readonly scenarios: readonly string[];
+    readonly status: string;
+    readonly story: string;
+    readonly url: string | undefined;
+}
+export declare const openOrder: readonly ["tested", "pending", "todo-only", "no-scenario", "code-tests", "none", "unclassified"];
+export declare const openLabels: Readonly<Record<OpenGroupType, string>>;
+export declare const openRows: (classified: readonly ClassifiedInterface[], scenarios: ScenariosInterface) => Promise<OpenRowInterface[]>;
+export declare const openCounts: (rows: readonly OpenRowInterface[]) => Record<OpenGroupType, number>;

package/dist/esm/scenarios/coverage-open.js

@@ -0,0 +1,71 @@
+import { scenarioState } from './acceptance-class.js';
+import { markPending, markTodo } from './config.js';
+import { liveScenarios } from './coverage-data.js';
+import { blobUrl, webUrl } from './remote.js';
+export const openOrder = [
+    'tested',
+    'pending',
+    'todo-only',
+    'no-scenario',
+    'code-tests',
+    'none',
+    'unclassified',
+];
+export const openLabels = {
+    'code-tests': 'проверка — тестами кода',
+    'no-scenario': 'сценария ещё нет',
+    none: 'проверять нечего',
+    pending: 'тест готов раньше реализации',
+    tested: 'тест есть',
+    'todo-only': `критерий перенесён, шагов нет (@${markTodo})`,
+    unclassified: 'класс не задан',
+};
+const e2eGroup = (story, scenarios) => {
+    const state = scenarioState(story.ids, scenarios.ids, scenarios.removed);
+    if (state === 'только долг') {
+        return 'todo-only';
+    }
+    if (state !== 'с тестом') {
+        return 'no-scenario';
+    }
+    const tested = liveScenarios(story.ids, scenarios).filter((scenario) => !scenario.tags.includes(markTodo));
+    return tested.every((scenario) => scenario.tags.includes(markPending)) ? 'pending' : 'tested';
+};
+const groupOf = (story, scenarios) => {
+    const { kinds } = story;
+    if (kinds === undefined) {
+        return 'unclassified';
+    }
+    if (kinds.includes('e2e')) {
+        return e2eGroup(story, scenarios);
+    }
+    return kinds.includes('code-tests') ? 'code-tests' : 'none';
+};
+const projectRows = async (item, scenarios) => {
+    const location = { commit: item.project.commit, web: await webUrl(scenarios.cwd, item.project.repo) };
+    return item.open.map((story) => ({
+        file: story.file,
+        group: groupOf(story, scenarios),
+        project: item.project.name,
+        scenarios: story.ids,
+        status: story.status,
+        story: story.key,
+        url: story.file === undefined ? undefined : blobUrl(location, story.file),
+    }));
+};
+export const openRows = async (classified, scenarios) => {
+    const rows = await Promise.all(classified.map(async (item) => projectRows(item, scenarios)));
+    return rows.flat().toSorted((left, right) => openOrder.indexOf(left.group) - openOrder.indexOf(right.group));
+};
+export const openCounts = (rows) => {
+    const count = (group) => rows.filter((row) => row.group === group).length;
+    return {
+        'code-tests': count('code-tests'),
+        'no-scenario': count('no-scenario'),
+        none: count('none'),
+        pending: count('pending'),
+        tested: count('tested'),
+        'todo-only': count('todo-only'),
+        unclassified: count('unclassified'),
+    };
+};

package/dist/esm/scenarios/coverage-page.d.ts

@@ -0,0 +1,2 @@
+import type { CoverageDataInterface } from './coverage.js';
+export declare const renderPage: (data: CoverageDataInterface) => string;

package/dist/esm/scenarios/coverage-page.js

@@ -0,0 +1,104 @@
+import { uncoveredLabels, uncoveredOrder } from './coverage-data.js';
+import { openCounts, openLabels, openOrder } from './coverage-open.js';
+import { capitalize, escapeHtml } from './python-text.js';
+const pageStyle = 'body{font:14px/1.5 system-ui,sans-serif;margin:24px;color:#1f2328;background:#fff}'
+    + 'h1{font-size:22px}h2{font-size:17px;margin-top:28px}p.note{color:#59636e;max-width:880px}'
+    + 'table{border-collapse:collapse;margin:8px 0}'
+    + 'th,td{border:1px solid #d0d7de;padding:4px 8px;text-align:left;vertical-align:top}th{background:#f6f8fa}'
+    + '@media (prefers-color-scheme:dark){body{color:#e6edf3;background:#0d1117}th{background:#161b22}'
+    + 'th,td{border-color:#30363d}p.note{color:#9198a1}a{color:#4493f8}}';
+const note = 'Классы приёмки story: e2e — сценарий этого репозитория против стенда снаружи, code-tests — тесты кода в '
+    + 'репозитории проекта, none — проверять нечего; story с набором классов учтена в каждом. Покрыта — закрытая story '
+    + 'с e2e, у которой хоть один сценарий идёт в прогон: не снят и без отметок @todo, @not-implemented, @quarantine. '
+    + 'Знаменатель — закрытые story с e2e без тех, все сценарии которых сняты.';
+const projectHead = [
+    'Проект',
+    'Задачи на',
+    'Закрытых',
+    'Знаменатель',
+    'Покрыто',
+    'Доля',
+    ...uncoveredOrder.map((state) => capitalize(uncoveredLabels[state])),
+    'Все сняты',
+    'code-tests',
+    'none',
+    'Без класса',
+];
+const linkTo = (text, url) => (url === undefined ? escapeHtml(text) : `<a href="${escapeHtml(url)}">${escapeHtml(text)}</a>`);
+const table = (head, rows) => {
+    if (rows.length === 0) {
+        return '<p>нет</p>';
+    }
+    const cells = head.map((cell) => `<th>${escapeHtml(cell)}</th>`).join('');
+    const body = rows.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join('')}</tr>`).join('');
+    return `<table><tr>${cells}</tr>${body}</table>`;
+};
+const items = (title, values) => {
+    const list = values.map((value) => `<li>${escapeHtml(value)}</li>`).join('');
+    const body = values.length > 0 ? `<ul>${list}</ul>` : '<p>нет</p>';
+    return `<h2>${escapeHtml(title)} (${values.length})</h2>${body}`;
+};
+const numbers = (values) => values.map((value) => escapeHtml(String(value)));
+const shareCell = (share) => (share === undefined ? '—' : escapeHtml(`${share}%`));
+const projectRows = (data) => data.projects.map((item) => [
+    escapeHtml(item.project),
+    escapeHtml(`${item.revision} ${item.commit.slice(0, 9)}`),
+    ...numbers([item.closed, item.denominator, item.covered]),
+    shareCell(item.share),
+    ...numbers(uncoveredOrder.map((state) => item.uncovered[state])),
+    ...numbers([item.allRemoved, item.codeTests, item.none, item.unclassified]),
+]);
+const uncoveredRows = (data) => data.uncovered.map((story) => [
+    linkTo(`${story.project}:${story.story}`, story.url),
+    escapeHtml(uncoveredLabels[story.state]),
+    escapeHtml(story.scenarios.join(', ') || '—'),
+]);
+const openNote = 'Незакрытые story (статус board — не done и не rejected) по готовности теста; в долю покрытия они не '
+    + 'входят. Тест есть — хоть один сценарий story с шагами не снят и не только ждёт реализации (в том числе в '
+    + 'карантине); класс не задан — поля нет, заготовка TODO или находка поля.';
+const openGroupRows = (data) => {
+    const counts = openCounts(data.open);
+    return openOrder.map((group) => [escapeHtml(capitalize(openLabels[group])), escapeHtml(String(counts[group]))]);
+};
+const openRows = (data) => data.open.map((story) => [
+    linkTo(`${story.project}:${story.story}`, story.url),
+    escapeHtml(story.status),
+    escapeHtml(openLabels[story.group]),
+    escapeHtml(story.scenarios.join(', ') || '—'),
+]);
+const referrersCell = (scenario) => {
+    const lines = scenario.stories
+        .map((story) => escapeHtml(`${story.project}/${story.file}:${story.line} — ${story.status || 'вне board'}`));
+    return lines.join('<br>') || 'ссылок нет';
+};
+const pendingRows = (data) => data.pending.map((scenario) => [
+    linkTo(scenario.id, scenario.url),
+    escapeHtml(scenario.title),
+    escapeHtml(`${scenario.file}:${scenario.line}`),
+    referrersCell(scenario),
+]);
+const removedRows = (data) => data.removed
+    .map((row) => [row.id, row.date, row.reason, row.story, row.replacedBy, row.commit].map((value) => escapeHtml(value)));
+export const renderPage = (data) => [
+    '<!doctype html><html lang="ru"><head><meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width,initial-scale=1">',
+    `<title>Покрытие задач</title><style>${pageStyle}</style></head><body>`,
+    '<h1>Покрытие задач приёмочными тестами</h1>',
+    `<p class="note">Дата: ${escapeHtml(data.date)}. ${note}</p>`,
+    '<h2>Покрытие</h2>',
+    table(projectHead, projectRows(data)),
+    `<h2>Закрытые без включённого теста (${data.uncovered.length})</h2>`,
+    table(['Story', 'Состояние', 'Сценарии story'], uncoveredRows(data)),
+    `<h2>Незакрытые по готовности теста (${data.open.length})</h2>`,
+    `<p class="note">${openNote}</p>`,
+    table(['Группа', 'Story'], openGroupRows(data)),
+    table(['Story', 'Статус', 'Группа', 'Сценарии story'], openRows(data)),
+    `<h2>Ждут реализации (${data.pending.length})</h2>`,
+    '<p class="note">Тест написан раньше реализации: сценарий с отметкой @not-implemented.</p>',
+    table(['Сценарий', 'Заголовок', 'Файл', 'Story со ссылкой'], pendingRows(data)),
+    `<h2>Снято за ${escapeHtml(data.period.since)} — ${escapeHtml(data.period.until)} (${data.removed.length})</h2>`,
+    table(['id', 'Дата', 'Причина', 'Story', 'Чем заменён', 'Коммит'], removedRows(data)),
+    items('Дефекты разметки', data.defects),
+    items('Примечания', data.notes),
+    '</body></html>\n',
+].join('');

package/dist/esm/scenarios/coverage-removed.d.ts

@@ -0,0 +1,13 @@
+export interface RemovedInInterface {
+    readonly notes: readonly string[];
+    readonly rows: readonly RemovedInPeriodInterface[];
+}
+export interface RemovedInPeriodInterface {
+    readonly commit: string;
+    readonly date: string;
+    readonly id: string;
+    readonly reason: string;
+    readonly replacedBy: string;
+    readonly story: string;
+}
+export declare const removedIn: (cwd: string, file: string, period: readonly [string, string]) => Promise<RemovedInInterface>;

package/dist/esm/scenarios/coverage-removed.js

@@ -0,0 +1,26 @@
+import { parseDate } from './dates.js';
+import { pyRepr } from './python-text.js';
+import { removedRows } from './removed-list.js';
+const datePattern = /^\d{4}-\d{2}-\d{2}$/u;
+const parsedDay = (text) => {
+    try {
+        return [parseDate(text)];
+    }
+    catch {
+        return [];
+    }
+};
+const dayOf = (text) => (datePattern.test(text) ? parsedDay(text)[0] : undefined);
+const inPeriod = (row, period, day) => {
+    const { commit, date, id, reason, replacedBy, story } = row;
+    return period[0] <= day && day <= period[1] ? [{ commit, date, id, reason, replacedBy, story }] : [];
+};
+const dateNote = (row, file) => `запись ${row.id} в ${file}:${row.line}: дата ${pyRepr(row.date)} не по формату ГГГГ-ММ-ДД — в «снято за период» не входит`;
+export const removedIn = async (cwd, file, period) => {
+    const rows = await removedRows(cwd, file);
+    const dated = rows.map((row) => [row, dayOf(row.date)]);
+    return {
+        notes: dated.filter(([, day]) => day === undefined).map(([row]) => dateNote(row, file)),
+        rows: dated.flatMap(([row, day]) => (day === undefined ? [] : inPeriod(row, period, day))),
+    };
+};

package/dist/esm/scenarios/coverage.d.ts

@@ -0,0 +1,26 @@
+import type { CoverageProjectInterface, PendingInterface, UncoveredStoryInterface } from './coverage-data.js';
+import type { OpenRowInterface } from './coverage-open.js';
+import type { RemovedInPeriodInterface } from './coverage-removed.js';
+import type { DeclaredInputInterface } from './declared.js';
+import type { ReportInterface } from './report.js';
+export interface CoverageDataInterface {
+    readonly date: string;
+    readonly defects: readonly string[];
+    readonly notes: readonly string[];
+    readonly open: readonly OpenRowInterface[];
+    readonly pending: readonly PendingInterface[];
+    readonly period: Readonly<{
+        since: string;
+        until: string;
+    }>;
+    readonly projects: readonly CoverageProjectInterface[];
+    readonly removed: readonly RemovedInPeriodInterface[];
+    readonly uncovered: readonly UncoveredStoryInterface[];
+}
+export interface CoverageOptionsInterface {
+    readonly json: string | undefined;
+    readonly out: string | undefined;
+    readonly period: readonly [string, string];
+    readonly today: string;
+}
+export declare const coverageCommand: (input: DeclaredInputInterface, options: CoverageOptionsInterface) => Promise<ReportInterface>;

package/dist/esm/scenarios/coverage.js

@@ -0,0 +1,84 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { classifyDeclared, noProjects, sourcesLine } from './classes.js';
+import { ConfigError } from './config.js';
+import { coverageOf, pendingScenarios, uncoveredLabels, uncoveredOrder } from './coverage-data.js';
+import { coverageJson } from './coverage-json.js';
+import { openCounts, openLabels, openOrder, openRows } from './coverage-open.js';
+import { renderPage } from './coverage-page.js';
+import { removedIn } from './coverage-removed.js';
+import { scenarioIds, worktreeFeatures } from './features.js';
+import { messageOf } from './python-text.js';
+import { parseRemoved } from './removed-list.js';
+import { readProjects } from './task-links.js';
+const projectPart = (item) => {
+    const share = item.share === undefined ? '—' : `${item.share}%`;
+    const states = uncoveredOrder.map((state) => `${uncoveredLabels[state]} ${item.uncovered[state]}`).join(', ');
+    const total = uncoveredOrder.reduce((sum, state) => sum + item.uncovered[state], 0);
+    return `${item.project} — покрыто ${item.covered} из ${item.denominator} (${share}), без включённого теста ${total} (${states})`;
+};
+const coverageLine = (projects) => {
+    const parts = projects.map((item) => projectPart(item)).join(' · ');
+    return `покрытие закрытых story: ${parts || noProjects}`;
+};
+const openPart = (item, rows) => {
+    const own = rows.filter((row) => row.project === item.project.name);
+    const counts = openCounts(own);
+    const groups = openOrder.map((group) => `${openLabels[group]} ${counts[group]}`).join(', ');
+    return `${item.project.name} — по группам ${own.length}, на board ${item.open.length} (${groups})`;
+};
+const openLine = (classified, rows) => {
+    const parts = classified.map((item) => openPart(item, rows)).join(' · ');
+    return `незакрытые story: ${parts || noProjects}`;
+};
+const writeOut = async (cwd, file, text) => {
+    try {
+        await mkdir(path.dirname(path.resolve(cwd, file)), { recursive: true });
+        await writeFile(path.resolve(cwd, file), text);
+    }
+    catch (error) {
+        throw new ConfigError(`${file} не записывается: ${messageOf(error)}`);
+    }
+};
+const scenariosOf = async (input, files) => {
+    const removed = await parseRemoved(input.cwd, input.config.removed);
+    return { config: input.config, cwd: input.cwd, ids: scenarioIds(input.config, files), removed: removed.entries };
+};
+const collect = async (input, options) => {
+    const files = await worktreeFeatures(input.cwd, input.config);
+    const scenarios = await scenariosOf(input, files);
+    const { classified, defects, notes } = await classifyDeclared(scenarios, input);
+    const { projects, uncovered } = await coverageOf(classified, scenarios);
+    const read = await readProjects(input);
+    const pending = await pendingScenarios(scenarios, files, read.rows);
+    const open = await openRows(classified, scenarios);
+    const inPeriod = await removedIn(input.cwd, input.config.removed, options.period);
+    const data = {
+        date: options.today,
+        defects,
+        notes: [...notes, ...inPeriod.notes],
+        open,
+        pending,
+        period: { since: options.period[0], until: options.period[1] },
+        projects,
+        removed: inPeriod.rows,
+        uncovered,
+    };
+    return { data, open: openLine(classified, open), sources: sourcesLine(classified.map((item) => item.project)) };
+};
+const isGiven = (file) => file !== undefined && file !== '';
+const writeIfGiven = async (cwd, target) => {
+    if (!isGiven(target.file)) {
+        return [];
+    }
+    await writeOut(cwd, target.file, target.text);
+    return [`${target.label}: ${target.file}`];
+};
+export const coverageCommand = async (input, options) => {
+    const { data, open, sources } = await collect(input, options);
+    const counts = `ждут реализации ${data.pending.length}, снято за ${data.period.since} — ${data.period.until}: ${data.removed.length}`;
+    const json = await writeIfGiven(input.cwd, { file: options.json, label: 'данные', text: coverageJson(data) });
+    const page = await writeIfGiven(input.cwd, { file: options.out, label: 'страница', text: renderPage(data) });
+    const summary = [coverageLine(data.projects), open, sources, counts, ...json, ...page].join('\n');
+    return { defects: data.defects, notes: data.notes, summary };
+};

package/dist/esm/scenarios/dates.d.ts

@@ -0,0 +1,8 @@
+export interface PeriodOptionsInterface {
+    readonly since: string | undefined;
+    readonly today: string;
+    readonly until: string | undefined;
+}
+export declare const parseDate: (text: string) => string;
+export declare const localToday: (now: Date) => string;
+export declare const periodOf: (options: PeriodOptionsInterface) => readonly [string, string];

package/dist/esm/scenarios/dates.js

@@ -0,0 +1,87 @@
+import { ConfigError } from './config.js';
+import { messageOf, pyRepr } from './python-text.js';
+const isoForm = /^(?<year>\d{4})(?<dash>-?)(?<month>\d{2})\k<dash>(?<day>\d{2})$/u;
+const periodDays = 30;
+const monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const eraDays = 146_097;
+const epochShift = 719_468;
+const isLeap = (year) => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+const daysIn = (year, month) => {
+    const isLeapFebruary = month === 2 && isLeap(year);
+    return isLeapFebruary ? 29 : monthDays[month - 1] ?? 0;
+};
+const dayError = ({ day, month, year }) => {
+    const last = daysIn(year, month);
+    return day < 1 || day > last ? `day ${day} must be in range 1..${last} for month ${month} in year ${year}` : undefined;
+};
+const rangeError = (civil) => {
+    if (civil.year < 1) {
+        return `year must be in 1..9999, not ${civil.year}`;
+    }
+    return civil.month < 1 || civil.month > 12 ? `month must be in 1..12, not ${civil.month}` : dayError(civil);
+};
+const pad = (value, width) => String(value).padStart(width, '0');
+const format = ({ day, month, year }) => `${pad(year, 4)}-${pad(month, 2)}-${pad(day, 2)}`;
+const marchMonth = (month) => (month > 2 ? month - 3 : month + 9);
+const toDays = ({ day, month, year }) => {
+    const shifted = month <= 2 ? year - 1 : year;
+    const era = Math.floor(shifted / 400);
+    const yearOfEra = shifted - (era * 400);
+    const dayOfYear = Math.floor(((153 * marchMonth(month)) + 2) / 5) + day - 1;
+    const leapDays = Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100);
+    return (era * eraDays) + (yearOfEra * 365) + leapDays + dayOfYear - epochShift;
+};
+const yearOfEraOf = (dayOfEra) => {
+    const leapDays = Math.floor(dayOfEra / 1460) - Math.floor(dayOfEra / 36_524) + Math.floor(dayOfEra / (eraDays - 1));
+    return Math.floor((dayOfEra - leapDays) / 365);
+};
+const fromDays = (days) => {
+    const shifted = days + epochShift;
+    const era = Math.floor(shifted / eraDays);
+    const dayOfEra = shifted - (era * eraDays);
+    const yearOfEra = yearOfEraOf(dayOfEra);
+    const dayOfYear = dayOfEra - ((365 * yearOfEra) + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));
+    const monthIndex = Math.floor(((5 * dayOfYear) + 2) / 153);
+    const month = monthIndex < 10 ? monthIndex + 3 : monthIndex - 9;
+    const day = dayOfYear - Math.floor(((153 * monthIndex) + 2) / 5) + 1;
+    return { day, month, year: yearOfEra + (era * 400) + (month <= 2 ? 1 : 0) };
+};
+export const parseDate = (text) => {
+    const groups = isoForm.exec(text)?.groups;
+    if (groups === undefined) {
+        throw new Error(`Invalid isoformat string: ${pyRepr(text)}`);
+    }
+    const civil = { day: Number(groups.day), month: Number(groups.month), year: Number(groups.year) };
+    const problem = rangeError(civil);
+    if (problem !== undefined) {
+        throw new Error(problem);
+    }
+    return format(civil);
+};
+export const localToday = (now) => format({
+    day: now.getDate(),
+    month: now.getMonth() + 1,
+    year: now.getFullYear(),
+});
+const minusDays = (date, days) => {
+    const [year = 0, month = 0, day = 0] = date.split('-').map(Number);
+    return format(fromDays(toDays({ day, month, year }) - days));
+};
+const isUnset = (text) => text === undefined || text === '';
+const dateOr = (text, fallback) => (isUnset(text) ? fallback() : parseDate(text));
+const parsePeriod = (options) => {
+    try {
+        const until = dateOr(options.until, () => options.today);
+        return [dateOr(options.since, () => minusDays(until, periodDays)), until];
+    }
+    catch (error) {
+        throw new ConfigError(`дата периода не по формату ГГГГ-ММ-ДД: ${messageOf(error)}`);
+    }
+};
+export const periodOf = (options) => {
+    const [since, until] = parsePeriod(options);
+    if (since > until) {
+        throw new ConfigError(`--since ${since} позже --until ${until}`);
+    }
+    return [since, until];
+};