@application-kit/acceptance 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPage = void 0;
+const coverage_data_js_1 = require("./coverage-data.js");
+const coverage_open_js_1 = require("./coverage-open.js");
+const python_text_js_1 = require("./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 = [
+    'Проект',
+    'Задачи на',
+    'Закрытых',
+    'Знаменатель',
+    'Покрыто',
+    'Доля',
+    ...coverage_data_js_1.uncoveredOrder.map((state) => (0, python_text_js_1.capitalize)(coverage_data_js_1.uncoveredLabels[state])),
+    'Все сняты',
+    'code-tests',
+    'none',
+    'Без класса',
+];
+const linkTo = (text, url) => (url === undefined ? (0, python_text_js_1.escapeHtml)(text) : `<a href="${(0, python_text_js_1.escapeHtml)(url)}">${(0, python_text_js_1.escapeHtml)(text)}</a>`);
+const table = (head, rows) => {
+    if (rows.length === 0) {
+        return '<p>нет</p>';
+    }
+    const cells = head.map((cell) => `<th>${(0, python_text_js_1.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>${(0, python_text_js_1.escapeHtml)(value)}</li>`).join('');
+    const body = values.length > 0 ? `<ul>${list}</ul>` : '<p>нет</p>';
+    return `<h2>${(0, python_text_js_1.escapeHtml)(title)} (${values.length})</h2>${body}`;
+};
+const numbers = (values) => values.map((value) => (0, python_text_js_1.escapeHtml)(String(value)));
+const shareCell = (share) => (share === undefined ? '—' : (0, python_text_js_1.escapeHtml)(`${share}%`));
+const projectRows = (data) => data.projects.map((item) => [
+    (0, python_text_js_1.escapeHtml)(item.project),
+    (0, python_text_js_1.escapeHtml)(`${item.revision} ${item.commit.slice(0, 9)}`),
+    ...numbers([item.closed, item.denominator, item.covered]),
+    shareCell(item.share),
+    ...numbers(coverage_data_js_1.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),
+    (0, python_text_js_1.escapeHtml)(coverage_data_js_1.uncoveredLabels[story.state]),
+    (0, python_text_js_1.escapeHtml)(story.scenarios.join(', ') || '—'),
+]);
+const openNote = 'Незакрытые story (статус board — не done и не rejected) по готовности теста; в долю покрытия они не '
+    + 'входят. Тест есть — хоть один сценарий story с шагами не снят и не только ждёт реализации (в том числе в '
+    + 'карантине); класс не задан — поля нет, заготовка TODO или находка поля.';
+const openGroupRows = (data) => {
+    const counts = (0, coverage_open_js_1.openCounts)(data.open);
+    return coverage_open_js_1.openOrder.map((group) => [(0, python_text_js_1.escapeHtml)((0, python_text_js_1.capitalize)(coverage_open_js_1.openLabels[group])), (0, python_text_js_1.escapeHtml)(String(counts[group]))]);
+};
+const openRows = (data) => data.open.map((story) => [
+    linkTo(`${story.project}:${story.story}`, story.url),
+    (0, python_text_js_1.escapeHtml)(story.status),
+    (0, python_text_js_1.escapeHtml)(coverage_open_js_1.openLabels[story.group]),
+    (0, python_text_js_1.escapeHtml)(story.scenarios.join(', ') || '—'),
+]);
+const referrersCell = (scenario) => {
+    const lines = scenario.stories
+        .map((story) => (0, python_text_js_1.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),
+    (0, python_text_js_1.escapeHtml)(scenario.title),
+    (0, python_text_js_1.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) => (0, python_text_js_1.escapeHtml)(value)));
+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">Дата: ${(0, python_text_js_1.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>Снято за ${(0, python_text_js_1.escapeHtml)(data.period.since)} — ${(0, python_text_js_1.escapeHtml)(data.period.until)} (${data.removed.length})</h2>`,
+    table(['id', 'Дата', 'Причина', 'Story', 'Чем заменён', 'Коммит'], removedRows(data)),
+    items('Дефекты разметки', data.defects),
+    items('Примечания', data.notes),
+    '</body></html>\n',
+].join('');
+exports.renderPage = renderPage;

package/dist/cjs/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/cjs/scenarios/coverage-removed.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removedIn = void 0;
+const dates_js_1 = require("./dates.js");
+const python_text_js_1 = require("./python-text.js");
+const removed_list_js_1 = require("./removed-list.js");
+const datePattern = /^\d{4}-\d{2}-\d{2}$/u;
+const parsedDay = (text) => {
+    try {
+        return [(0, dates_js_1.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}: дата ${(0, python_text_js_1.pyRepr)(row.date)} не по формату ГГГГ-ММ-ДД — в «снято за период» не входит`;
+const removedIn = async (cwd, file, period) => {
+    const rows = await (0, removed_list_js_1.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))),
+    };
+};
+exports.removedIn = removedIn;

package/dist/cjs/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/cjs/scenarios/coverage.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverageCommand = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const classes_js_1 = require("./classes.js");
+const config_js_1 = require("./config.js");
+const coverage_data_js_1 = require("./coverage-data.js");
+const coverage_json_js_1 = require("./coverage-json.js");
+const coverage_open_js_1 = require("./coverage-open.js");
+const coverage_page_js_1 = require("./coverage-page.js");
+const coverage_removed_js_1 = require("./coverage-removed.js");
+const features_js_1 = require("./features.js");
+const python_text_js_1 = require("./python-text.js");
+const removed_list_js_1 = require("./removed-list.js");
+const task_links_js_1 = require("./task-links.js");
+const projectPart = (item) => {
+    const share = item.share === undefined ? '—' : `${item.share}%`;
+    const states = coverage_data_js_1.uncoveredOrder.map((state) => `${coverage_data_js_1.uncoveredLabels[state]} ${item.uncovered[state]}`).join(', ');
+    const total = coverage_data_js_1.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 || classes_js_1.noProjects}`;
+};
+const openPart = (item, rows) => {
+    const own = rows.filter((row) => row.project === item.project.name);
+    const counts = (0, coverage_open_js_1.openCounts)(own);
+    const groups = coverage_open_js_1.openOrder.map((group) => `${coverage_open_js_1.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 || classes_js_1.noProjects}`;
+};
+const writeOut = async (cwd, file, text) => {
+    try {
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(node_path_1.default.resolve(cwd, file)), { recursive: true });
+        await (0, promises_1.writeFile)(node_path_1.default.resolve(cwd, file), text);
+    }
+    catch (error) {
+        throw new config_js_1.ConfigError(`${file} не записывается: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const scenariosOf = async (input, files) => {
+    const removed = await (0, removed_list_js_1.parseRemoved)(input.cwd, input.config.removed);
+    return { config: input.config, cwd: input.cwd, ids: (0, features_js_1.scenarioIds)(input.config, files), removed: removed.entries };
+};
+const collect = async (input, options) => {
+    const files = await (0, features_js_1.worktreeFeatures)(input.cwd, input.config);
+    const scenarios = await scenariosOf(input, files);
+    const { classified, defects, notes } = await (0, classes_js_1.classifyDeclared)(scenarios, input);
+    const { projects, uncovered } = await (0, coverage_data_js_1.coverageOf)(classified, scenarios);
+    const read = await (0, task_links_js_1.readProjects)(input);
+    const pending = await (0, coverage_data_js_1.pendingScenarios)(scenarios, files, read.rows);
+    const open = await (0, coverage_open_js_1.openRows)(classified, scenarios);
+    const inPeriod = await (0, coverage_removed_js_1.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: (0, classes_js_1.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}`];
+};
+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: (0, coverage_json_js_1.coverageJson)(data) });
+    const page = await writeIfGiven(input.cwd, { file: options.out, label: 'страница', text: (0, coverage_page_js_1.renderPage)(data) });
+    const summary = [coverageLine(data.projects), open, sources, counts, ...json, ...page].join('\n');
+    return { defects: data.defects, notes: data.notes, summary };
+};
+exports.coverageCommand = coverageCommand;

package/dist/cjs/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/cjs/scenarios/dates.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.periodOf = exports.localToday = exports.parseDate = void 0;
+const config_js_1 = require("./config.js");
+const python_text_js_1 = require("./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) };
+};
+const parseDate = (text) => {
+    const groups = isoForm.exec(text)?.groups;
+    if (groups === undefined) {
+        throw new Error(`Invalid isoformat string: ${(0, python_text_js_1.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);
+};
+exports.parseDate = parseDate;
+const localToday = (now) => format({
+    day: now.getDate(),
+    month: now.getMonth() + 1,
+    year: now.getFullYear(),
+});
+exports.localToday = localToday;
+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() : (0, exports.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 config_js_1.ConfigError(`дата периода не по формату ГГГГ-ММ-ДД: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const periodOf = (options) => {
+    const [since, until] = parsePeriod(options);
+    if (since > until) {
+        throw new config_js_1.ConfigError(`--since ${since} позже --until ${until}`);
+    }
+    return [since, until];
+};
+exports.periodOf = periodOf;

package/dist/cjs/scenarios/declared.d.ts

@@ -0,0 +1,18 @@
+import type { ConfigInterface } from './config.js';
+import type { ProjectInterface } from './projects.js';
+export interface DeclaredInputInterface {
+    readonly config: ConfigInterface;
+    readonly cwd: string;
+    readonly projects: string;
+    readonly revisions: ReadonlyMap<string, string>;
+}
+export interface DeclaredInterface {
+    readonly declared: readonly DeclaredProjectInterface[];
+    readonly notes: readonly string[];
+}
+interface DeclaredProjectInterface {
+    readonly defect: string | undefined;
+    readonly project: ProjectInterface;
+}
+export declare const declaredProjects: (input: DeclaredInputInterface) => Promise<DeclaredInterface>;
+export {};

package/dist/cjs/scenarios/declared.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declaredProjects = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const board_js_1 = require("./board.js");
+const config_js_1 = require("./config.js");
+const features_js_1 = require("./features.js");
+const git_js_1 = require("./git.js");
+const projects_js_1 = require("./projects.js");
+const python_text_js_1 = require("./python-text.js");
+const repoFromKey = (value, projects) => {
+    const text = (0, python_text_js_1.pyText)(value).trim();
+    if (text.startsWith('projects/')) {
+        return (0, features_js_1.joinPath)(projects, text.slice('projects/'.length));
+    }
+    return node_path_1.default.isAbsolute(text) ? text : undefined;
+};
+const keyValue = (project) => {
+    if (project.board === undefined) {
+        return undefined;
+    }
+    let header;
+    try {
+        header = (0, board_js_1.parseBoard)(project.board);
+    }
+    catch (error) {
+        throw new config_js_1.ConfigError(`board проекта ${project.name} на ${project.revision} не читается: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+    return (0, board_js_1.isRecord)(header) ? header[board_js_1.acceptanceKey] : undefined;
+};
+const isSet = (value) => {
+    if ((0, board_js_1.isRecord)(value)) {
+        return Object.keys(value).length > 0;
+    }
+    return Array.isArray(value) ? value.length > 0 : Boolean(value);
+};
+const defectOf = (config, project, value) => {
+    const defect = `board проекта ${project.name} объявляет этот репозиторий тестов (${board_js_1.acceptanceKey}: ${(0, python_text_js_1.pyText)(value)}), а «id» `
+        + 'конфига проект не покрывает — ссылки его story не распознаются';
+    return (0, config_js_1.isProjectCovered)(config, project.name) ? undefined : defect;
+};
+const isOwnRepo = async (cwd, own, repo) => {
+    const common = await (0, git_js_1.commonDirectory)(cwd, repo);
+    return own !== undefined && common === own;
+};
+const probe = async (input, own, project) => {
+    const value = keyValue(project);
+    if (!isSet(value)) {
+        return undefined;
+    }
+    const repo = repoFromKey(value, input.projects);
+    if (repo === undefined) {
+        return `проект ${project.name} пропущен — ${board_js_1.acceptanceKey}: ${(0, python_text_js_1.pyRepr)(value)}, ждём projects/<репозиторий> или абсолютный путь`;
+    }
+    return await isOwnRepo(input.cwd, own, repo) ? { defect: defectOf(input.config, project, value), project } : undefined;
+};
+const declaredProjects = async (input) => {
+    const own = await (0, git_js_1.commonDirectory)(input.cwd, '.');
+    const walk = await (0, projects_js_1.walkProjects)(input);
+    const probes = await Promise.all(walk.projects.map(async (project) => probe(input, own, project)));
+    return {
+        declared: probes.filter((item) => typeof item === 'object'),
+        notes: [...walk.notes, ...probes.filter((item) => typeof item === 'string')],
+    };
+};
+exports.declaredProjects = declaredProjects;

package/dist/cjs/scenarios/features.d.ts

@@ -0,0 +1,13 @@
+import type { ConfigInterface } from './config.js';
+import type { ScenarioInterface } from './gherkin.js';
+export type FilesType = ReadonlyMap<string, string>;
+export declare const joinPath: (directory: string, name: string) => string;
+export declare const isFile: (cwd: string, file: string) => Promise<boolean>;
+export declare const isDirectory: (target: string) => Promise<boolean>;
+export declare const walkFiles: (cwd: string, directory: string, extension: string) => Promise<string[]>;
+export declare const readText: (cwd: string, file: string) => Promise<string>;
+export declare const worktreeFeatures: (cwd: string, config: ConfigInterface) => Promise<FilesType>;
+export declare const baseFeatures: (cwd: string, config: ConfigInterface, base: string) => Promise<FilesType>;
+export declare const allScenarios: (files: FilesType) => ScenarioInterface[];
+export declare const scenarioIds: (config: ConfigInterface, files: FilesType) => Map<string, ScenarioInterface[]>;
+export declare const countMark: (scenarios: readonly ScenarioInterface[], mark: string) => number;

package/dist/cjs/scenarios/features.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countMark = exports.scenarioIds = exports.allScenarios = exports.baseFeatures = exports.worktreeFeatures = exports.readText = exports.walkFiles = exports.isDirectory = exports.isFile = exports.joinPath = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const config_js_1 = require("./config.js");
+const gherkin_js_1 = require("./gherkin.js");
+const git_js_1 = require("./git.js");
+const python_text_js_1 = require("./python-text.js");
+const joinPath = (directory, name) => {
+    const separator = directory.endsWith('/') ? '' : '/';
+    return `${directory}${separator}${name}`;
+};
+exports.joinPath = joinPath;
+const isFile = async (cwd, file) => {
+    try {
+        await (0, promises_1.access)(node_path_1.default.resolve(cwd, file));
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isFile = isFile;
+const isDirectory = async (target) => {
+    try {
+        const found = await (0, promises_1.stat)(target);
+        return found.isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+exports.isDirectory = isDirectory;
+const kindOf = async (entry, absolute) => {
+    if (entry.isSymbolicLink()) {
+        return await (0, exports.isDirectory)(absolute) ? undefined : 'file';
+    }
+    return entry.isDirectory() ? 'directory' : 'file';
+};
+const listDirectory = async (absolute) => {
+    try {
+        return await (0, promises_1.readdir)(absolute, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+};
+const kindsOf = async (cwd, directory) => {
+    const entries = await listDirectory(node_path_1.default.resolve(cwd, directory));
+    const kinds = await Promise.all(entries.map(async (entry) => {
+        const kind = await kindOf(entry, node_path_1.default.resolve(cwd, directory, entry.name));
+        return [entry.name, kind];
+    }));
+    return new Map(kinds);
+};
+const walkFiles = async (cwd, directory, extension) => {
+    const kinds = await kindsOf(cwd, directory);
+    const names = (0, python_text_js_1.sortedText)(kinds.keys());
+    const files = names.filter((name) => kinds.get(name) === 'file' && name.endsWith(extension));
+    const directories = names.filter((name) => kinds.get(name) === 'directory');
+    const nested = await Promise.all(directories
+        .map(async (name) => (0, exports.walkFiles)(cwd, (0, exports.joinPath)(directory, name), extension)));
+    return [...files.map((name) => (0, exports.joinPath)(directory, name)), ...nested.flat()];
+};
+exports.walkFiles = walkFiles;
+const readText = async (cwd, file) => {
+    const text = await (0, promises_1.readFile)(node_path_1.default.resolve(cwd, file), 'utf8');
+    return (0, python_text_js_1.universalNewlines)(text);
+};
+exports.readText = readText;
+const readAll = async (files, read) => {
+    const texts = await Promise.all(files.map(async (file) => [file, await read(file)]));
+    return new Map(texts);
+};
+const worktreeFeatures = async (cwd, config) => {
+    const files = await (0, exports.walkFiles)(cwd, config.features, '.feature');
+    return readAll(files, async (file) => (0, exports.readText)(cwd, file));
+};
+exports.worktreeFeatures = worktreeFeatures;
+const showOrEmpty = async (cwd, revision) => {
+    const text = await (0, git_js_1.git)(cwd, git_js_1.currentRepo, ['show', revision]);
+    return text ?? '';
+};
+const baseFeatures = async (cwd, config, base) => {
+    const listed = await (0, git_js_1.runGit)({ cwd, repo: git_js_1.currentRepo }, ['ls-tree', '-r', '--name-only', base, '--', config.features]);
+    if (listed.code !== 0) {
+        throw new config_js_1.ConfigError(`git ls-tree ${base} не прошёл: ${listed.stderr.trim()}`);
+    }
+    const files = (0, git_js_1.stdoutText)(listed).split('\n')
+        .filter((file) => file.endsWith('.feature'));
+    return readAll(files, async (file) => showOrEmpty(cwd, `${base}:./${file}`));
+};
+exports.baseFeatures = baseFeatures;
+const allScenarios = (files) => [...files]
+    .flatMap(([file, text]) => (0, gherkin_js_1.parseFeature)(text, file));
+exports.allScenarios = allScenarios;
+const scenarioIds = (config, files) => {
+    const tagged = (0, exports.allScenarios)(files).flatMap((scenario) => scenario.tags
+        .filter((tag) => config.id.test(tag))
+        .map((tag) => ({ scenario, tag })));
+    const grouped = Map.groupBy(tagged, ({ tag }) => tag);
+    return new Map([...grouped].map(([tag, items]) => [tag, items.map(({ scenario }) => scenario)]));
+};
+exports.scenarioIds = scenarioIds;
+const countMark = (scenarios, mark) => scenarios
+    .filter((scenario) => scenario.tags.includes(mark))
+    .length;
+exports.countMark = countMark;

package/dist/cjs/scenarios/gherkin.d.ts

@@ -0,0 +1,10 @@
+export interface ScenarioInterface {
+    readonly file: string;
+    readonly line: number;
+    readonly tags: readonly string[];
+    readonly title: string;
+}
+export declare const parseFeature: (text: string, file: string) => ScenarioInterface[];
+export declare const featureTags: (text: string) => readonly string[];
+export declare const featureLanguage: (text: string) => string;
+export declare const where: (scenario: ScenarioInterface) => string;