@application-kit/acceptance 0.0.0-stage → 0.1.1

package/dist/esm/scenarios/lint-inputs.js

@@ -0,0 +1,110 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { ConfigError, markPending, marks } from './config.js';
+import { messageOf, pyText, sortedText, splitLines } from './python-text.js';
+const unusedHeader = /Unused steps \((?<count>\d+)\)/u;
+const unusedRow = /^[|│]\s*(?<pattern>.+?)\s*[|│]\s*(?<location>\S+:\d+)\s*[|│]\s*$/u;
+const isJson = (value) => typeof value === 'object' && value !== null;
+const asRecord = (value) => (isJson(value) ? value : {});
+const asList = (value) => (Array.isArray(value) ? value : []);
+const readInput = async (cwd, file, describe) => {
+    try {
+        return await readFile(path.resolve(cwd, file), 'utf8');
+    }
+    catch (error) {
+        throw new ConfigError(`${describe} ${file} не читается: ${messageOf(error)}`);
+    }
+};
+const readJson = async (cwd, file) => {
+    const text = await readInput(cwd, file, 'список тестов');
+    try {
+        return asRecord(JSON.parse(text));
+    }
+    catch (error) {
+        throw new ConfigError(`список тестов ${file} не читается: ${messageOf(error)}`);
+    }
+};
+const walkSpecs = (suite) => [
+    ...asList(suite.specs).map((spec) => asRecord(spec)),
+    ...asList(suite.suites).flatMap((child) => walkSpecs(asRecord(child))),
+];
+const errorText = (error) => {
+    const record = asRecord(error);
+    return pyText('message' in record ? record.message : error);
+};
+const specTags = (spec) => asList(spec.tags).map(String);
+const markedTags = (spec) => {
+    const tags = new Set(specTags(spec));
+    return sortedText(marks.filter((mark) => tags.has(mark)));
+};
+const blockingDefects = (context, spec, project) => {
+    const marked = markedTags(spec).map((mark) => `@${mark}`)
+        .join(', ');
+    const isLeak = marked !== '' && context.blocking.includes(project);
+    return isLeak ? [`блокирующий проект «${project}» выбирает отмеченный сценарий (${marked}): ${pyText(spec.title)}`] : [];
+};
+const pendingDefects = (context, spec, project) => {
+    const isStray = project === context.pending && !specTags(spec).includes(markPending);
+    return isStray ? [`проект «${context.pending}» выбирает сценарий без @${markPending}: ${pyText(spec.title)}`] : [];
+};
+const testDefects = (context, spec, test) => {
+    const project = pyText(test.projectName);
+    return [...blockingDefects(context, spec, project), ...pendingDefects(context, spec, project)];
+};
+const projectDefects = (data, context) => {
+    const projects = asList(asRecord(data.config).projects).map((project) => pyText(asRecord(project).name));
+    const listed = projects.join(', ') || 'нет';
+    return [...context.blocking, context.pending]
+        .filter((name) => !projects.includes(name))
+        .map((name) => `нет проекта Playwright «${name}» (проекты: ${listed})`);
+};
+const contextOf = (config) => {
+    if (config.blocking.length === 0 || config.pending === undefined) {
+        throw new ConfigError('для --list-json в конфиге нужны «blocking» и «pending»');
+    }
+    return { blocking: config.blocking, pending: config.pending };
+};
+const specTests = (data) => asList(data.suites)
+    .flatMap((suite) => walkSpecs(asRecord(suite)))
+    .flatMap((spec) => asList(spec.tests).map((test) => [spec, asRecord(test)]));
+export const lintList = async (config, cwd, file) => {
+    const data = await readJson(cwd, file);
+    const errors = asList(data.errors).map((error) => `playwright --list: ${errorText(error)}`);
+    const context = contextOf(config);
+    const pairs = specTests(data);
+    const isMarked = pairs.some(([spec]) => markedTags(spec).length > 0);
+    return {
+        defects: [
+            ...errors,
+            ...projectDefects(data, context),
+            ...pairs.flatMap(([spec, test]) => testDefects(context, spec, test)),
+        ],
+        notes: isMarked ? [] : ['отмеченных сценариев в списке нет — исключение их блокирующим проектом не проверено'],
+        tests: pairs.length,
+    };
+};
+const unusedRowOf = (line) => {
+    const groups = unusedRow.exec(line)?.groups;
+    return groups === undefined ? [] : [[String(groups.pattern), String(groups.location)]];
+};
+const duplicateSteps = (rows) => sortedText(new Set(rows.map(([pattern]) => pattern)))
+    .map((pattern) => [pattern, rows.filter(([name]) => name === pattern).map(([, location]) => location)])
+    .filter(([, locations]) => locations.length > 1)
+    .map(([pattern, locations]) => `дубль шага «${pattern}»: ${locations.join(', ')}`);
+const declaredCount = (text, file) => {
+    const groups = unusedHeader.exec(text)?.groups;
+    if (groups === undefined) {
+        throw new ConfigError(`в ${file} нет строки «Unused steps (N)» — формат вывода bddgen сменился`);
+    }
+    return Number(groups.count);
+};
+export const lintUnused = async (cwd, file) => {
+    const text = await readInput(cwd, file, 'вывод неиспользуемых шагов');
+    const declared = declaredCount(text, file);
+    const rows = splitLines(text).flatMap((line) => unusedRowOf(line));
+    if (rows.length !== declared) {
+        throw new ConfigError(`bddgen объявил ${declared} неиспользуемых шагов, разобрано ${rows.length} — формат вывода сменился`);
+    }
+    const unused = rows.map(([pattern, location]) => `неиспользуемый шаг «${pattern}»: ${location}`);
+    return { count: rows.length, defects: [...unused, ...duplicateSteps(rows)] };
+};

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

@@ -0,0 +1,8 @@
+import type { ConfigInterface } from './config.js';
+import type { ReportInterface } from './report.js';
+export interface LintOptionsInterface {
+    readonly listJson: string | undefined;
+    readonly unusedSteps: string | undefined;
+}
+export declare const lintCommand: (cwd: string, config: ConfigInterface, options: LintOptionsInterface) => Promise<ReportInterface>;
+export declare const removedCommand: (cwd: string, config: ConfigInterface, base: string) => Promise<ReportInterface>;

package/dist/esm/scenarios/lint.js

@@ -0,0 +1,89 @@
+import { markPending, markQuarantine, marks, markTodo } from './config.js';
+import { allScenarios, baseFeatures, countMark, scenarioIds, worktreeFeatures } from './features.js';
+import { where } from './gherkin.js';
+import { lintList, lintUnused } from './lint-inputs.js';
+import { compareText, sortedText } from './python-text.js';
+import { parseRemoved } from './removed-list.js';
+const noPart = { defects: [], notes: [], summary: '' };
+const isGiven = (file) => file !== undefined && file !== '';
+const idDefects = (config, scenario) => {
+    const ids = scenario.tags.filter((tag) => config.id.test(tag));
+    if (ids.length === 0) {
+        return [`без id критерия: ${where(scenario)}`];
+    }
+    return ids.length > 1 ? [`несколько id (${ids.join(', ')}): ${where(scenario)}`] : [];
+};
+const groupDefects = (config, scenario) => {
+    const hasGroup = scenario.tags.some((tag) => config.groups.includes(tag));
+    return hasGroup ? [] : [`без тега группы (${config.groups.join(', ')}): ${where(scenario)}`];
+};
+const todoDefects = (scenario) => {
+    const others = sortedText(new Set(scenario.tags.filter((tag) => tag === markPending || tag === markQuarantine)));
+    const listed = others.map((mark) => `@${mark}`).join(', ');
+    const isMixed = others.length > 0 && scenario.tags.includes(markTodo);
+    return isMixed ? [`@${markTodo} вместе с ${listed} — теста ещё нет, отметка состояния теста ему не нужна: ${where(scenario)}`] : [];
+};
+const scenarioDefects = (config, scenario) => [
+    ...idDefects(config, scenario),
+    ...groupDefects(config, scenario),
+    ...todoDefects(scenario),
+];
+const duplicateIds = (ids) => sortedText(ids.keys())
+    .map((tag) => [tag, ids.get(tag) ?? []])
+    .filter(([, owners]) => owners.length > 1)
+    .map(([tag, owners]) => `id ${tag} у ${owners.length} сценариев: ${owners.map((owner) => where(owner)).join('; ')}`);
+const listPart = async (config, cwd, file) => {
+    if (!isGiven(file)) {
+        return noPart;
+    }
+    const result = await lintList(config, cwd, file);
+    return { ...result, summary: `, тестов в списке Playwright ${result.tests}` };
+};
+const unusedPart = async (cwd, file) => {
+    if (!isGiven(file)) {
+        return noPart;
+    }
+    const result = await lintUnused(cwd, file);
+    return { defects: result.defects, notes: [], summary: `, неиспользуемых шагов ${result.count}` };
+};
+export const lintCommand = async (cwd, config, options) => {
+    const files = await worktreeFeatures(cwd, config);
+    const scenarios = allScenarios(files);
+    const list = await listPart(config, cwd, options.listJson);
+    const unused = await unusedPart(cwd, options.unusedSteps);
+    const counts = marks.map((mark) => `@${mark} ${countMark(scenarios, mark)}`).join(', ');
+    const read = `прочитано: feature-файлов ${files.size}, сценариев ${scenarios.length}`;
+    return {
+        defects: [
+            ...scenarios.flatMap((scenario) => scenarioDefects(config, scenario)),
+            ...duplicateIds(scenarioIds(config, files)),
+            ...list.defects,
+            ...unused.defects,
+        ],
+        notes: list.notes,
+        summary: `${read}${list.summary}${unused.summary}\nотметки: ${counts}`,
+    };
+};
+const reusedDefect = (config, id, line, owner) => {
+    const place = where(owner);
+    return `id ${id} снят (${config.removed}:${line}), но снова в ${place} — id не переиспользуются и не переименовываются`;
+};
+export const removedCommand = async (cwd, config, base) => {
+    const before = scenarioIds(config, await baseFeatures(cwd, config, base));
+    const now = scenarioIds(config, await worktreeFeatures(cwd, config));
+    const removed = await parseRemoved(cwd, config.removed);
+    const gone = sortedText(before.keys()).filter((id) => !now.has(id) && !removed.entries.has(id));
+    const reused = [...removed.entries]
+        .toSorted(([left], [right]) => compareText(left, right))
+        .flatMap(([id, line]) => (now.get(id) ?? []).slice(0, 1).map((owner) => reusedDefect(config, id, line, owner)));
+    const read = `прочитано: id на базе ${base} ${before.size}, id на ветке ${now.size}`;
+    return {
+        defects: [
+            ...removed.defects,
+            ...gone.map((id) => `id ${id} исчез из feature-файлов без записи в ${config.removed}`),
+            ...reused,
+        ],
+        notes: [],
+        summary: `${read}, записей в ${config.removed} ${removed.entries.size}`,
+    };
+};

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

@@ -0,0 +1,21 @@
+export interface ProjectInterface {
+    readonly board: string | undefined;
+    readonly commit: string | undefined;
+    readonly name: string;
+    readonly repo: string;
+    readonly revision: string | undefined;
+}
+export interface ProjectsInputInterface {
+    readonly cwd: string;
+    readonly projects: string;
+    readonly revisions: ReadonlyMap<string, string>;
+}
+export interface WalkInterface {
+    readonly notes: readonly string[];
+    readonly projects: readonly ProjectInterface[];
+}
+export declare const parseRevisions: (cwd: string, projects: string, items: readonly string[]) => Promise<Map<string, string>>;
+export declare const walkProjects: (input: ProjectsInputInterface) => Promise<WalkInterface>;
+export declare const sourceOf: (project: ProjectInterface) => string;
+export declare const projectStatuses: (cwd: string, project: ProjectInterface) => Promise<Map<string, string>>;
+export declare const storyKey: (file: string) => string;

package/dist/esm/scenarios/projects.js

@@ -0,0 +1,104 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { boardStatuses } from './board.js';
+import { ConfigError } from './config.js';
+import { isDirectory, isFile, joinPath, readText } from './features.js';
+import { commonDirectory, currentRepo, git } from './git.js';
+import { sortedText } from './python-text.js';
+const ownBoard = 'tasks/board.yaml';
+const commitSuffix = '^{commit}';
+const splitRevision = (item) => {
+    const index = item.indexOf('=');
+    return [item.slice(0, index), item.slice(index + 1)];
+};
+export const parseRevisions = async (cwd, projects, items) => {
+    const parsed = new Map(items.filter((item) => item.includes('=')).map((item) => splitRevision(item)));
+    if (parsed.size !== items.length) {
+        throw new ConfigError('--ref ждёт <проект>=<ref>');
+    }
+    if (!await isDirectory(path.resolve(cwd, projects))) {
+        throw new ConfigError(`каталога проектов ${projects} нет`);
+    }
+    return parsed;
+};
+const projectNames = async (cwd, projects) => {
+    const names = await readdir(path.resolve(cwd, projects));
+    const flags = await Promise.all(names.map(async (name) => isDirectory(path.resolve(cwd, projects, name))));
+    return sortedText(names.filter((_, index) => flags[index] === true));
+};
+const skipNote = (name, commit, revision) => {
+    const missing = commit === undefined ? 'ref ' : `${ownBoard} на `;
+    return `проект ${name} пропущен — нет ${missing}${revision}`;
+};
+const isText = (text) => text !== undefined && text !== '';
+const projectAtRevision = async (input, source) => {
+    const { name, repo } = source;
+    const revision = input.revisions.get(name) ?? source.fallback;
+    const commit = await git(input.cwd, repo, ['rev-parse', '--verify', '-q', `${revision}${commitSuffix}`]);
+    const board = await git(input.cwd, repo, ['show', `${revision}:${ownBoard}`]);
+    return !isText(board) || !isText(commit)
+        ? skipNote(name, commit, revision)
+        : { board, commit: commit.trim(), name, repo, revision };
+};
+const foreignProject = async (input, name) => projectAtRevision(input, { fallback: 'origin/main', name, repo: joinPath(input.projects, name) });
+const hostRoot = async (cwd) => {
+    const output = await git(cwd, currentRepo, ['rev-parse', '--show-cdup']);
+    const root = output?.trim();
+    return root === '' ? undefined : root;
+};
+const ownProject = (name) => ({
+    board: undefined,
+    commit: undefined,
+    name,
+    repo: currentRepo,
+    revision: undefined,
+});
+const probe = async (input, own, name) => {
+    const common = await commonDirectory(input.cwd, joinPath(input.projects, name));
+    if (own.common === undefined || common !== own.common) {
+        return foreignProject(input, name);
+    }
+    return own.host === undefined
+        ? ownProject(name)
+        : projectAtRevision(input, { fallback: 'HEAD', name, repo: own.host });
+};
+const checkRevisions = (input, names) => {
+    const unknown = sortedText([...input.revisions.keys()].filter((name) => !names.includes(name)));
+    if (unknown.length > 0) {
+        throw new ConfigError(`--ref для проектов, которых нет в ${input.projects}: ${unknown.join(', ')}`);
+    }
+};
+const isProject = (item) => typeof item === 'object';
+const withOwn = (found, hasOwnBoard) => {
+    const isOwnSeen = found.some((project) => project.revision === undefined);
+    const projects = found.filter((project) => hasOwnBoard || project.revision !== undefined);
+    return isOwnSeen || !hasOwnBoard ? projects : [...projects, ownProject('.')];
+};
+export const walkProjects = async (input) => {
+    const own = { common: await commonDirectory(input.cwd, currentRepo), host: await hostRoot(input.cwd) };
+    const names = await projectNames(input.cwd, input.projects);
+    checkRevisions(input, names);
+    const hasOwnBoard = await isFile(input.cwd, ownBoard);
+    const probes = await Promise.all(names.map(async (name) => probe(input, own, name)));
+    return {
+        notes: probes.filter((item) => typeof item === 'string'),
+        projects: withOwn(probes.filter((item) => isProject(item)), hasOwnBoard),
+    };
+};
+export const sourceOf = (project) => (project.revision === undefined
+    ? `${project.name} — рабочее дерево`
+    : `${project.name} — ${project.revision} ${(project.commit ?? '').slice(0, 9)}`);
+export const projectStatuses = async (cwd, project) => {
+    if (project.revision !== undefined) {
+        return boardStatuses(project.board ?? '', `проекта ${project.name} на ${project.revision}`);
+    }
+    if (await isFile(cwd, 'tasks/status.log')) {
+        throw new ConfigError('рядом с board лежит status.log, упразднённый форматом 6: статусы живут в самом board');
+    }
+    return boardStatuses(await readText(cwd, ownBoard), ownBoard);
+};
+export const storyKey = (file) => {
+    const name = path.posix.basename(file);
+    const dot = name.lastIndexOf('.');
+    return dot > 0 ? name.slice(0, dot) : name;
+};

package/dist/esm/scenarios/python-text.d.ts

@@ -0,0 +1,11 @@
+export declare const splitLines: (text: string) => string[];
+export declare const universalNewlines: (text: string) => string;
+export declare const compareText: (left: string, right: string) => number;
+export declare const sortedText: (values: Iterable<string>) => string[];
+export declare const pyRepr: (value: unknown) => string;
+export declare const pyText: (value: unknown) => string;
+export declare const roundTenth: (value: number) => number;
+export declare const capitalize: (text: string) => string;
+export declare const escapeHtml: (text: string) => string;
+export declare const quotePath: (text: string) => string;
+export declare const messageOf: (error: unknown) => string;

package/dist/esm/scenarios/python-text.js

@@ -0,0 +1,81 @@
+const breakChars = [0x0A, 0x0B, 0x0C, 0x0D, 0x1C, 0x1D, 0x1E, 0x85, 0x20_28, 0x20_29]
+    .map((code) => String.fromCodePoint(code))
+    .join('');
+const lineBreak = new RegExp(`\r\n|[${breakChars}]`, 'u');
+const notPrintable = /[\p{C}\p{Z}]/u;
+const urlSafe = /[\w\-./~]/u;
+const namedEscapes = { '\t': String.raw `\t`, '\n': String.raw `\n`, '\r': String.raw `\r` };
+export const splitLines = (text) => {
+    const lines = text.split(lineBreak);
+    return lines.at(-1) === '' ? lines.slice(0, -1) : lines;
+};
+export const universalNewlines = (text) => text.replaceAll(/\r\n?/gu, '\n');
+const codePoints = (text) => Array.from(text, (char) => char.codePointAt(0) ?? 0);
+export const compareText = (left, right) => {
+    const leftPoints = codePoints(left);
+    const rightPoints = codePoints(right);
+    const index = leftPoints.findIndex((point, position) => point !== rightPoints[position]);
+    return index === -1 ? leftPoints.length - rightPoints.length : (leftPoints[index] ?? 0) - (rightPoints[index] ?? -1);
+};
+export const sortedText = (values) => [...values].toSorted(compareText);
+const hexEscape = (char) => {
+    const hex = (char.codePointAt(0) ?? 0).toString(16);
+    if (hex.length <= 2) {
+        return String.raw `\x${hex.padStart(2, '0')}`;
+    }
+    return hex.length <= 4 ? String.raw `\u${hex.padStart(4, '0')}` : String.raw `\U${hex.padStart(8, '0')}`;
+};
+const escapePrintable = (char) => (char === ' ' || !notPrintable.test(char) ? char : hexEscape(char));
+const escapeQuoted = (char, quote) => {
+    const isSpecial = char === quote || char === '\\';
+    return isSpecial ? `\\${char}` : escapePrintable(char);
+};
+const reprText = (text) => {
+    const quote = text.includes('\'') && !text.includes('"') ? '"' : '\'';
+    const body = Array.from(text, (char) => namedEscapes[char] ?? escapeQuoted(char, quote)).join('');
+    return `${quote}${body}${quote}`;
+};
+const booleanRepr = (isTrue) => (isTrue ? 'True' : 'False');
+const numberRepr = (value) => (typeof value === 'number' ? String(value) : 'None');
+const reprScalar = (value) => (typeof value === 'boolean' ? booleanRepr(value) : numberRepr(value));
+const reprObject = (value, repr) => {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => repr(item)).join(', ')}]`;
+    }
+    return `{${Object.entries(value).map(([key, item]) => `${reprText(key)}: ${repr(item)}`)
+        .join(', ')}}`;
+};
+export const pyRepr = (value) => {
+    if (typeof value === 'string') {
+        return reprText(value);
+    }
+    return typeof value === 'object' && value !== null ? reprObject(value, pyRepr) : reprScalar(value);
+};
+export const pyText = (value) => (typeof value === 'string' ? value : pyRepr(value));
+export const roundTenth = (value) => {
+    const quarters = value * 4;
+    if (Number.isSafeInteger(quarters) && Math.abs(quarters % 2) === 1) {
+        const lower = Math.floor(value * 10);
+        return (lower % 2 === 0 ? lower : lower + 1) / 10;
+    }
+    return Number(value.toFixed(1));
+};
+export const capitalize = (text) => {
+    const [first = '', ...rest] = [...text];
+    return `${first.toUpperCase()}${rest.join('').toLowerCase()}`;
+};
+export const escapeHtml = (text) => text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll('\'', '&#x27;');
+const quoteByte = (byte) => `%${byte.toString(16).toUpperCase()
+    .padStart(2, '0')}`;
+const quoteBytes = (char) => [...new TextEncoder().encode(char)]
+    .map((byte) => quoteByte(byte))
+    .join('');
+const quoteChar = (char) => (urlSafe.test(char) ? char : quoteBytes(char));
+export const quotePath = (text) => Array.from(text, (char) => quoteChar(char)).join('');
+const isError = (error) => error instanceof Error;
+export const messageOf = (error) => (isError(error) ? error.message : String(error));

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

@@ -0,0 +1,6 @@
+export interface BlobLocationInterface {
+    readonly commit: string | undefined;
+    readonly web: string | undefined;
+}
+export declare const webUrl: (cwd: string, repo: string) => Promise<string | undefined>;
+export declare const blobUrl: (location: BlobLocationInterface, file: string, line?: number) => string | undefined;

package/dist/esm/scenarios/remote.js

@@ -0,0 +1,24 @@
+import { git } from './git.js';
+import { quotePath } from './python-text.js';
+const remoteForms = [
+    /^(?<scheme>https?):\/\/(?:[^/@]*@)?(?<host>[^/@]+)\/(?<path>.+?)(?:\.git)?\/?$/u,
+    /^ssh:\/\/(?:[^/@]*@)?(?<host>[^/:@]+)(?::\d+)?\/(?<path>.+?)(?:\.git)?\/?$/u,
+    /^[^/:@]+@(?<host>[^/:@]+):(?<path>[^/].*?)(?:\.git)?\/?$/u,
+];
+export const webUrl = async (cwd, repo) => {
+    const remote = await git(cwd, repo, ['remote', 'get-url', 'origin']);
+    if (remote === undefined) {
+        return undefined;
+    }
+    const address = remote.trim();
+    const groups = remoteForms.map((form) => form.exec(address)?.groups).find((found) => found !== undefined);
+    return groups === undefined ? undefined : `${groups.scheme ?? 'https'}://${groups.host}/${groups.path}`;
+};
+const hasCommit = (location) => location.commit !== undefined && location.commit !== '';
+export const blobUrl = (location, file, line) => {
+    if (location.web === undefined || !hasCommit(location)) {
+        return undefined;
+    }
+    const anchor = line === undefined ? '' : `#L${line}`;
+    return `${location.web}/-/blob/${location.commit}/${quotePath(file)}${anchor}`;
+};

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

@@ -0,0 +1,15 @@
+export interface RemovedListInterface {
+    readonly defects: readonly string[];
+    readonly entries: ReadonlyMap<string, number>;
+}
+export interface RemovedRowInterface {
+    readonly commit: string;
+    readonly date: string;
+    readonly id: string;
+    readonly line: number;
+    readonly reason: string;
+    readonly replacedBy: string;
+    readonly story: string;
+}
+export declare const removedRows: (cwd: string, file: string) => Promise<RemovedRowInterface[]>;
+export declare const parseRemoved: (cwd: string, file: string) => Promise<RemovedListInterface>;

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

@@ -0,0 +1,57 @@
+import { isFile, readText } from './features.js';
+import { splitLines } from './python-text.js';
+const fieldColumns = [
+    ['дата', 'date'],
+    ['причина', 'reason'],
+    ['story', 'story'],
+    ['чем заменён', 'replacedBy'],
+    ['коммит', 'commit'],
+];
+const emptyCells = new Set(['', '-', '—']);
+const separatorCell = /^[ \-:]*$/u;
+const stripChars = (text, chars) => {
+    const kept = [...text];
+    const start = kept.findIndex((char) => !chars.includes(char));
+    const end = kept.findLastIndex((char) => !chars.includes(char));
+    return kept.slice(start, end + 1).join('');
+};
+const cellsOf = (line) => stripChars(line.trim(), '|')
+    .split('|')
+    .map((cell) => stripChars(cell.trim(), '`').trim());
+const cellAt = (cells, index) => cells[index] ?? '';
+const isRecord = (first) => first !== 'id' && !separatorCell.test(first);
+const rowOf = (cells, line) => ({
+    commit: cellAt(cells, 5),
+    date: cellAt(cells, 1),
+    id: cellAt(cells, 0).replace(/^@+/u, ''),
+    line,
+    reason: cellAt(cells, 2),
+    replacedBy: cellAt(cells, 4),
+    story: cellAt(cells, 3),
+});
+const recordOf = (line, index) => {
+    const cells = cellsOf(line);
+    const isRow = line.trimStart().startsWith('|') && isRecord(cellAt(cells, 0));
+    return isRow ? [rowOf(cells, index + 1)] : [];
+};
+export const removedRows = async (cwd, file) => {
+    if (!await isFile(cwd, file)) {
+        return [];
+    }
+    const text = await readText(cwd, file);
+    return splitLines(text).flatMap((line, index) => recordOf(line, index));
+};
+const missingFields = (row) => fieldColumns
+    .filter(([, column]) => emptyCells.has(row[column]))
+    .map(([name]) => name);
+const rowDefects = (row, file) => {
+    const missing = missingFields(row);
+    return missing.length > 0 ? [`запись ${row.id} в ${file}:${row.line} без полей: ${missing.join(', ')}`] : [];
+};
+export const parseRemoved = async (cwd, file) => {
+    const rows = await removedRows(cwd, file);
+    return {
+        defects: rows.flatMap((row) => rowDefects(row, file)),
+        entries: new Map(rows.map((row) => [row.id, row.line])),
+    };
+};

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

@@ -0,0 +1,6 @@
+export interface ReportInterface {
+    readonly defects: readonly string[];
+    readonly notes: readonly string[];
+    readonly summary: string;
+}
+export declare const formatReport: (report: ReportInterface) => string;

package/dist/esm/scenarios/report.js

@@ -0,0 +1,6 @@
+export const formatReport = (report) => [
+    report.summary,
+    ...report.notes.map((note) => `примечание: ${note}`),
+    ...report.defects.map((defect) => `дефект: ${defect}`),
+    `итого: дефектов ${report.defects.length}`,
+].map((line) => `${line}\n`).join('');

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

@@ -0,0 +1,10 @@
+export interface RunContextInterface {
+    readonly cwd: string;
+    readonly now: Date;
+}
+export interface RunResultInterface {
+    readonly code: number;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+export declare const runScenarios: (argv: readonly string[], context: RunContextInterface) => Promise<RunResultInterface>;