@application-kit/acceptance 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storyKey = exports.projectStatuses = exports.sourceOf = exports.walkProjects = exports.parseRevisions = void 0;
+const promises_1 = require("node:fs/promises");
+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 python_text_js_1 = require("./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)];
+};
+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 config_js_1.ConfigError('--ref ждёт <проект>=<ref>');
+    }
+    if (!await (0, features_js_1.isDirectory)(node_path_1.default.resolve(cwd, projects))) {
+        throw new config_js_1.ConfigError(`каталога проектов ${projects} нет`);
+    }
+    return parsed;
+};
+exports.parseRevisions = parseRevisions;
+const projectNames = async (cwd, projects) => {
+    const names = await (0, promises_1.readdir)(node_path_1.default.resolve(cwd, projects));
+    const flags = await Promise.all(names.map(async (name) => (0, features_js_1.isDirectory)(node_path_1.default.resolve(cwd, projects, name))));
+    return (0, python_text_js_1.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 foreignProject = async (input, name) => {
+    const repo = (0, features_js_1.joinPath)(input.projects, name);
+    const revision = input.revisions.get(name) ?? 'origin/main';
+    const commit = await (0, git_js_1.git)(input.cwd, repo, ['rev-parse', '--verify', '-q', `${revision}${commitSuffix}`]);
+    const board = await (0, git_js_1.git)(input.cwd, repo, ['show', `${revision}:${ownBoard}`]);
+    return !isText(board) || !isText(commit)
+        ? skipNote(name, commit, revision)
+        : { board, commit: commit.trim(), name, repo, revision };
+};
+const ownProject = (name) => ({
+    board: undefined,
+    commit: undefined,
+    name,
+    repo: git_js_1.currentRepo,
+    revision: undefined,
+});
+const probe = async (input, own, name) => {
+    const common = await (0, git_js_1.commonDirectory)(input.cwd, (0, features_js_1.joinPath)(input.projects, name));
+    return own !== undefined && common === own ? ownProject(name) : foreignProject(input, name);
+};
+const checkRevisions = (input, names) => {
+    const unknown = (0, python_text_js_1.sortedText)([...input.revisions.keys()].filter((name) => !names.includes(name)));
+    if (unknown.length > 0) {
+        throw new config_js_1.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('.')];
+};
+const walkProjects = async (input) => {
+    const own = await (0, git_js_1.commonDirectory)(input.cwd, git_js_1.currentRepo);
+    const names = await projectNames(input.cwd, input.projects);
+    checkRevisions(input, names);
+    const hasOwnBoard = await (0, features_js_1.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),
+    };
+};
+exports.walkProjects = walkProjects;
+const sourceOf = (project) => (project.revision === undefined
+    ? `${project.name} — рабочее дерево`
+    : `${project.name} — ${project.revision} ${(project.commit ?? '').slice(0, 9)}`);
+exports.sourceOf = sourceOf;
+const projectStatuses = async (cwd, project) => {
+    if (project.revision !== undefined) {
+        return (0, board_js_1.boardStatuses)(project.board ?? '', `проекта ${project.name} на ${project.revision}`);
+    }
+    if (await (0, features_js_1.isFile)(cwd, 'tasks/status.log')) {
+        throw new config_js_1.ConfigError('рядом с board лежит status.log, упразднённый форматом 6: статусы живут в самом board');
+    }
+    return (0, board_js_1.boardStatuses)(await (0, features_js_1.readText)(cwd, ownBoard), ownBoard);
+};
+exports.projectStatuses = projectStatuses;
+const storyKey = (file) => {
+    const name = node_path_1.default.posix.basename(file);
+    const dot = name.lastIndexOf('.');
+    return dot > 0 ? name.slice(0, dot) : name;
+};
+exports.storyKey = storyKey;

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageOf = exports.quotePath = exports.escapeHtml = exports.capitalize = exports.roundTenth = exports.pyText = exports.pyRepr = exports.sortedText = exports.compareText = exports.universalNewlines = exports.splitLines = void 0;
+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` };
+const splitLines = (text) => {
+    const lines = text.split(lineBreak);
+    return lines.at(-1) === '' ? lines.slice(0, -1) : lines;
+};
+exports.splitLines = splitLines;
+const universalNewlines = (text) => text.replaceAll(/\r\n?/gu, '\n');
+exports.universalNewlines = universalNewlines;
+const codePoints = (text) => Array.from(text, (char) => char.codePointAt(0) ?? 0);
+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);
+};
+exports.compareText = compareText;
+const sortedText = (values) => [...values].toSorted(exports.compareText);
+exports.sortedText = sortedText;
+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(', ')}}`;
+};
+const pyRepr = (value) => {
+    if (typeof value === 'string') {
+        return reprText(value);
+    }
+    return typeof value === 'object' && value !== null ? reprObject(value, exports.pyRepr) : reprScalar(value);
+};
+exports.pyRepr = pyRepr;
+const pyText = (value) => (typeof value === 'string' ? value : (0, exports.pyRepr)(value));
+exports.pyText = pyText;
+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));
+};
+exports.roundTenth = roundTenth;
+const capitalize = (text) => {
+    const [first = '', ...rest] = [...text];
+    return `${first.toUpperCase()}${rest.join('').toLowerCase()}`;
+};
+exports.capitalize = capitalize;
+const escapeHtml = (text) => text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll('\'', '&#x27;');
+exports.escapeHtml = escapeHtml;
+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));
+const quotePath = (text) => Array.from(text, (char) => quoteChar(char)).join('');
+exports.quotePath = quotePath;
+const isError = (error) => error instanceof Error;
+const messageOf = (error) => (isError(error) ? error.message : String(error));
+exports.messageOf = messageOf;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blobUrl = exports.webUrl = void 0;
+const git_js_1 = require("./git.js");
+const python_text_js_1 = require("./python-text.js");
+const remoteForms = [
+    /^(?<scheme>https?):\/\/(?:[^/@]*@)?(?<host>[^/@]+)\/(?<path>.+?)(?:\.git)?\/?$/u,
+    /^ssh:\/\/(?:[^/@]*@)?(?<host>[^/:@]+)(?::\d+)?\/(?<path>.+?)(?:\.git)?\/?$/u,
+    /^[^/:@]+@(?<host>[^/:@]+):(?<path>[^/].*?)(?:\.git)?\/?$/u,
+];
+const webUrl = async (cwd, repo) => {
+    const remote = await (0, git_js_1.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}`;
+};
+exports.webUrl = webUrl;
+const hasCommit = (location) => location.commit !== undefined && location.commit !== '';
+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}/${(0, python_text_js_1.quotePath)(file)}${anchor}`;
+};
+exports.blobUrl = blobUrl;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRemoved = exports.removedRows = void 0;
+const features_js_1 = require("./features.js");
+const python_text_js_1 = require("./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)] : [];
+};
+const removedRows = async (cwd, file) => {
+    if (!await (0, features_js_1.isFile)(cwd, file)) {
+        return [];
+    }
+    const text = await (0, features_js_1.readText)(cwd, file);
+    return (0, python_text_js_1.splitLines)(text).flatMap((line, index) => recordOf(line, index));
+};
+exports.removedRows = removedRows;
+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(', ')}`] : [];
+};
+const parseRemoved = async (cwd, file) => {
+    const rows = await (0, exports.removedRows)(cwd, file);
+    return {
+        defects: rows.flatMap((row) => rowDefects(row, file)),
+        entries: new Map(rows.map((row) => [row.id, row.line])),
+    };
+};
+exports.parseRemoved = parseRemoved;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatReport = void 0;
+const formatReport = (report) => [
+    report.summary,
+    ...report.notes.map((note) => `примечание: ${note}`),
+    ...report.defects.map((defect) => `дефект: ${defect}`),
+    `итого: дефектов ${report.defects.length}`,
+].map((line) => `${line}\n`).join('');
+exports.formatReport = formatReport;

package/dist/cjs/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>;

package/dist/cjs/scenarios/run.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScenarios = void 0;
+const node_util_1 = require("node:util");
+const classes_js_1 = require("./classes.js");
+const config_js_1 = require("./config.js");
+const coverage_js_1 = require("./coverage.js");
+const dates_js_1 = require("./dates.js");
+const inventory_js_1 = require("./inventory.js");
+const links_js_1 = require("./links.js");
+const lint_js_1 = require("./lint.js");
+const projects_js_1 = require("./projects.js");
+const python_text_js_1 = require("./python-text.js");
+const report_js_1 = require("./report.js");
+const usage = `usage: scenarios [--config <файл>] <команда>
+  lint [--list-json <файл>] [--unused-steps <файл>]
+  removed --base <ref>
+  links --projects <каталог> [--ref <проект>=<ref>]…
+  classes --projects <каталог> [--ref <проект>=<ref>]… [--list]
+  coverage --projects <каталог> [--ref <проект>=<ref>]… [--since <дата>] [--until <дата>]
+           [--out <файл.html>] [--json <файл.json>]
+  inventory --out <файл.json> [--story <файл>]…
+Коды возврата: 0 — дефектов нет; 1 — есть дефекты; 2 — ошибка вызова или конфига.
+`;
+const text = { type: 'string' };
+const defaultConfig = 'scenarios.config.json';
+const configPrefix = '--config=';
+const flagErrorCode = 'ERR_PARSE_ARGS';
+const projectOptions = { projects: text, ref: { multiple: true, type: 'string' } };
+const commandOptions = {
+    classes: { ...projectOptions, list: { type: 'boolean' } },
+    coverage: { ...projectOptions, json: text, out: text, since: text, until: text },
+    inventory: { out: text, story: { multiple: true, type: 'string' } },
+    links: projectOptions,
+    lint: { 'list-json': text, 'unused-steps': text },
+    removed: { base: text },
+};
+const requiredOptions = {
+    classes: ['projects'],
+    coverage: ['projects'],
+    inventory: ['out'],
+    links: ['projects'],
+    lint: [],
+    removed: ['base'],
+};
+class UsageError extends Error {
+    name = 'UsageError';
+}
+const optional = (values, name) => {
+    const value = values[name];
+    return typeof value === 'string' ? value : undefined;
+};
+const required = (values, name) => {
+    const value = optional(values, name);
+    if (value === undefined) {
+        throw new UsageError(`нужен --${name}`);
+    }
+    return value;
+};
+const projectInput = async (context, config, values) => {
+    const projects = required(values, 'projects');
+    const items = Array.isArray(values.ref) ? values.ref.map(String) : [];
+    const revisions = await (0, projects_js_1.parseRevisions)(context.cwd, projects, items);
+    return { config, cwd: context.cwd, projects, revisions };
+};
+const coverage = async (context, config, values) => {
+    const today = (0, dates_js_1.localToday)(context.now);
+    const period = (0, dates_js_1.periodOf)({ since: optional(values, 'since'), today, until: optional(values, 'until') });
+    const input = await projectInput(context, config, values);
+    return (0, coverage_js_1.coverageCommand)(input, { json: optional(values, 'json'), out: optional(values, 'out'), period, today });
+};
+const handlers = {
+    classes: async (context, config, values) => {
+        const input = await projectInput(context, config, values);
+        return (0, classes_js_1.classesCommand)(input, values.list === true);
+    },
+    coverage,
+    inventory: async (context, config, values) => (0, inventory_js_1.inventoryCommand)(context.cwd, config, {
+        out: required(values, 'out'),
+        stories: Array.isArray(values.story) ? values.story.map(String) : [],
+    }),
+    links: async (context, config, values) => (0, links_js_1.linksCommand)(config, await projectInput(context, config, values)),
+    lint: async (context, config, values) => (0, lint_js_1.lintCommand)(context.cwd, config, {
+        listJson: optional(values, 'list-json'),
+        unusedSteps: optional(values, 'unused-steps'),
+    }),
+    removed: async (context, config, values) => (0, lint_js_1.removedCommand)(context.cwd, config, required(values, 'base')),
+};
+const isCommand = (name) => Object.hasOwn(commandOptions, name);
+const inlineConfig = (first, argv) => {
+    const isInline = first?.startsWith(configPrefix) === true;
+    return isInline ? [first.slice(configPrefix.length), argv.slice(1)] : [defaultConfig, argv];
+};
+const splitGlobal = (argv) => {
+    const [first, second] = argv;
+    return first === '--config' && second !== undefined ? [second, argv.slice(2)] : inlineConfig(first, argv);
+};
+const commandOf = (name) => {
+    if (!isCommand(name)) {
+        throw new UsageError(name === '' ? 'нужна команда' : `команды «${name}» нет`);
+    }
+    return name;
+};
+const parseCommand = (argv) => {
+    const [configFile, rest] = splitGlobal(argv);
+    const [name = '', ...options] = rest;
+    const command = commandOf(name);
+    const parsed = (0, node_util_1.parseArgs)({ allowPositionals: false, args: options, options: commandOptions[command], strict: true });
+    const { values } = parsed;
+    const names = requiredOptions[command];
+    for (const option of names) {
+        required(values, option);
+    }
+    return { command, configFile, values };
+};
+const codeOf = (error) => String(Reflect.get(new Object(error), 'code'));
+const isUsageError = (error) => error instanceof UsageError || codeOf(error).startsWith(flagErrorCode);
+const failure = (error) => {
+    if (error instanceof config_js_1.ConfigError) {
+        return { code: 2, stderr: `ошибка: ${error.message}\n`, stdout: '' };
+    }
+    if (isUsageError(error)) {
+        return { code: 2, stderr: `${usage}ошибка вызова: ${(0, python_text_js_1.messageOf)(error)}\n`, stdout: '' };
+    }
+    throw error;
+};
+const isHelp = (argv) => argv.includes('--help') || argv.includes('-h');
+const execute = async (argv, context) => {
+    const { command, configFile, values } = parseCommand(argv);
+    const config = await (0, config_js_1.loadConfig)(configFile, context.cwd);
+    const report = await handlers[command](context, config, values);
+    return { code: report.defects.length > 0 ? 1 : 0, stderr: '', stdout: (0, report_js_1.formatReport)(report) };
+};
+const runScenarios = async (argv, context) => {
+    if (isHelp(argv)) {
+        return { code: 0, stderr: '', stdout: usage };
+    }
+    try {
+        return await execute(argv, context);
+    }
+    catch (error) {
+        return failure(error);
+    }
+};
+exports.runScenarios = runScenarios;

package/dist/cjs/scenarios/task-links.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectsInputInterface } from './projects.js';
+export interface LinkRowInterface {
+    readonly file: string;
+    readonly line: number;
+    readonly project: string;
+    readonly status: string;
+    readonly text: string;
+}
+export interface ReadProjectsInterface {
+    readonly notes: readonly string[];
+    readonly rows: readonly LinkRowInterface[];
+    readonly sources: readonly string[];
+}
+export declare const linkToken: RegExp;
+export declare const readProjects: (input: ProjectsInputInterface) => Promise<ReadProjectsInterface>;

package/dist/cjs/scenarios/task-links.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjects = exports.linkToken = void 0;
+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");
+exports.linkToken = /@(?<project>[\da-z][\d\-a-z]*):AC-[\d\-.A-Za-z]*[\dA-Za-z]/gu;
+const linkGrep = '@[a-z0-9][a-z0-9-]*:AC-';
+const hasLink = (text) => text.match(exports.linkToken) !== null;
+const fileLines = async (cwd, file) => {
+    const text = await (0, features_js_1.readText)(cwd, file);
+    return (0, python_text_js_1.splitLines)(text).flatMap((line, index) => (hasLink(line) ? [[file, index + 1, line]] : []));
+};
+const ownTaskLines = async (cwd) => {
+    const files = await (0, features_js_1.walkFiles)(cwd, 'tasks', '.md');
+    const lines = await Promise.all(files.map(async (file) => fileLines(cwd, file)));
+    return lines.flat();
+};
+const splitGrepLine = (line) => {
+    const first = line.indexOf(':');
+    const second = line.indexOf(':', first + 1);
+    const file = line.slice(0, first);
+    return second === -1 || !file.endsWith('.md')
+        ? []
+        : [[file, Number(line.slice(first + 1, second)), line.slice(second + 1)]];
+};
+const revisionTaskLines = async (cwd, project, revision) => {
+    const done = await (0, git_js_1.runGit)({ cwd, repo: project.repo }, ['grep', '-n', '-I', '-E', linkGrep, revision, '--', 'tasks']);
+    if (done.code > 1 || done.code < 0) {
+        throw new config_js_1.ConfigError(`git grep в ${project.repo} на ${revision} не прошёл: ${done.stderr.trim()}`);
+    }
+    return (0, python_text_js_1.splitLines)((0, git_js_1.stdoutText)(done))
+        .flatMap((line) => splitGrepLine(line.slice(revision.length + 1)));
+};
+const taskLines = async (cwd, project) => (project.revision === undefined ? ownTaskLines(cwd) : revisionTaskLines(cwd, project, project.revision));
+const projectRows = async (cwd, project) => {
+    const statuses = await (0, projects_js_1.projectStatuses)(cwd, project);
+    const lines = await taskLines(cwd, project);
+    return lines.map(([file, line, text]) => ({
+        file,
+        line,
+        project: project.name,
+        status: statuses.get((0, projects_js_1.storyKey)(file)) ?? '',
+        text,
+    }));
+};
+const readProjects = async (input) => {
+    const walk = await (0, projects_js_1.walkProjects)(input);
+    const rows = await Promise.all(walk.projects.map(async (project) => projectRows(input.cwd, project)));
+    return { notes: walk.notes, rows: rows.flat(), sources: walk.projects.map((project) => (0, projects_js_1.sourceOf)(project)) };
+};
+exports.readProjects = readProjects;

package/dist/esm/bin/application-scenarios.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/esm/bin/application-scenarios.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { runScenarios } from '../scenarios/run.js';
+const main = async () => {
+    const result = await runScenarios(process.argv.slice(2), { cwd: process.cwd(), now: new Date() });
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exitCode = result.code;
+};
+void main();

package/dist/esm/bin/index.d.ts

@@ -0,0 +1 @@
+export * from './application-scenarios.js';

package/dist/esm/bin/index.js

@@ -0,0 +1 @@
+export * from './application-scenarios.js';

package/dist/esm/cadence/index.d.ts

@@ -0,0 +1 @@
+export * from './resolve-cadence.js';

package/dist/esm/cadence/index.js

@@ -0,0 +1 @@
+export * from './resolve-cadence.js';

package/dist/esm/cadence/resolve-cadence.d.ts

@@ -0,0 +1,8 @@
+export interface CadenceInterface {
+    readonly exclude: readonly string[];
+    readonly include: readonly string[];
+    readonly name: string;
+}
+type Variables = Readonly<Record<string, string | undefined>>;
+export declare const resolveCadence: (variables: Variables) => CadenceInterface;
+export {};

package/dist/esm/cadence/resolve-cadence.js

@@ -0,0 +1,14 @@
+const regression = { exclude: ['@nightly'], include: [], name: 'regression' };
+const smoke = { exclude: [], include: ['@smoke'], name: 'smoke' };
+const nightly = { exclude: [], include: ['@nightly'], name: 'nightly' };
+const cadences = [nightly, regression, smoke];
+export const resolveCadence = (variables) => {
+    const requested = variables.ACCEPTANCE_CADENCE ?? '';
+    const name = requested === '' ? regression.name : requested;
+    const cadence = cadences.find((candidate) => candidate.name === name);
+    if (cadence === undefined) {
+        const known = cadences.map((candidate) => candidate.name).join(', ');
+        throw new Error(`ACCEPTANCE_CADENCE: каденса «${name}» нет (есть: ${known})`);
+    }
+    return cadence;
+};