@application-kit/acceptance 0.0.0-stage → 0.1.1

package/dist/cjs/scenarios/gherkin.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.where = exports.featureLanguage = exports.featureTags = exports.parseFeature = void 0;
+const python_text_js_1 = require("./python-text.js");
+const startFeature = (state) => {
+    state.featureTags = state.pendingTags;
+    state.ruleTags = [];
+};
+const startRule = (state) => {
+    state.ruleTags = state.pendingTags;
+};
+const addScenario = (state, line, number) => {
+    state.scenarios.push({
+        line: number,
+        tags: [...state.featureTags, ...state.ruleTags, ...state.pendingTags],
+        title: line.slice(line.indexOf(':') + 1).trim(),
+    });
+};
+const skipTags = () => {
+};
+const headings = [
+    [['Feature', 'Business Need', 'Ability', 'Функция', 'Функциональность', 'Функционал', 'Свойство'], startFeature],
+    [['Rule', 'Правило'], startRule],
+    [
+        [
+            'Scenario Outline',
+            'Scenario Template',
+            'Scenario',
+            'Example',
+            'Структура сценария',
+            'Шаблон сценария',
+            'Сценарий',
+            'Пример',
+        ],
+        addScenario,
+    ],
+    [['Examples', 'Scenarios', 'Примеры', 'Background', 'Предыстория', 'Контекст'], skipTags],
+];
+const headingOf = (line) => headings
+    .find(([words]) => words.some((word) => line.startsWith(`${word}:`)))?.[1];
+const commentTail = /#.*/u;
+const lineTags = (line) => line
+    .replace(commentTail, '')
+    .split(/\s/u)
+    .filter((tag) => tag.startsWith('@'))
+    .map((tag) => tag.slice(1));
+const consumeLine = (state, line, number) => {
+    if (line.startsWith('@')) {
+        state.pendingTags = [...state.pendingTags, ...lineTags(line)];
+        return;
+    }
+    const heading = headingOf(line);
+    if (heading === undefined) {
+        return;
+    }
+    heading(state, line, number);
+    state.pendingTags = [];
+};
+const parseState = (text) => {
+    const state = { featureTags: [], pendingTags: [], ruleTags: [], scenarios: [] };
+    for (const [index, raw] of (0, python_text_js_1.splitLines)(text).entries()) {
+        consumeLine(state, raw.trim(), index + 1);
+    }
+    return state;
+};
+const parseFeature = (text, file) => parseState(text).scenarios
+    .map((scenario) => ({ file, ...scenario }));
+exports.parseFeature = parseFeature;
+const featureTags = (text) => parseState(text).featureTags;
+exports.featureTags = featureTags;
+const languageLine = /^[\t ]*#[\t ]*language:[\t ]*(?<language>\S+)/mu;
+const featureLanguage = (text) => languageLine.exec(text)?.groups?.language ?? 'en';
+exports.featureLanguage = featureLanguage;
+const where = (scenario) => `${scenario.file}:${scenario.line} «${scenario.title}»`;
+exports.where = where;

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

@@ -0,0 +1,15 @@
+export interface GitResultInterface {
+    readonly code: number;
+    readonly stderr: string;
+    readonly stdout: Buffer;
+}
+export interface RepoInterface {
+    readonly cwd: string;
+    readonly repo: string;
+}
+export declare const currentRepo = ".";
+export declare const runGit: (location: RepoInterface, gitArguments: readonly string[], input?: string) => Promise<GitResultInterface>;
+export declare const stdoutText: (result: GitResultInterface) => string;
+export declare const git: (cwd: string, repo: string, gitArguments: readonly string[]) => Promise<string | undefined>;
+export declare const commonDirectory: (cwd: string, repo: string) => Promise<string | undefined>;
+export declare const readAtRevision: (location: RepoInterface, revision: string, files: readonly string[]) => Promise<Map<string, string>>;

package/dist/cjs/scenarios/git.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAtRevision = exports.commonDirectory = exports.git = exports.stdoutText = exports.runGit = exports.currentRepo = void 0;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const config_js_1 = require("./config.js");
+const python_text_js_1 = require("./python-text.js");
+exports.currentRepo = '.';
+const decoder = new TextDecoder('utf-8');
+const ignorePipeError = () => {
+};
+const runGit = async (location, gitArguments, input = '') => new Promise((resolve) => {
+    const child = (0, node_child_process_1.spawn)('git', ['-C', location.repo, ...gitArguments], { cwd: location.cwd });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on('data', (chunk) => {
+        stdout.push(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+        stderr.push(chunk);
+    });
+    child.stdin.on('error', ignorePipeError);
+    child.on('error', (error) => {
+        resolve({ code: -1, stderr: error.message, stdout: Buffer.alloc(0) });
+    });
+    child.on('close', (code) => {
+        resolve({ code: code ?? -1, stderr: Buffer.concat(stderr).toString('utf8'), stdout: Buffer.concat(stdout) });
+    });
+    child.stdin.end(input);
+});
+exports.runGit = runGit;
+const stdoutText = (result) => (0, python_text_js_1.universalNewlines)(result.stdout.toString('utf8'));
+exports.stdoutText = stdoutText;
+const git = async (cwd, repo, gitArguments) => {
+    const done = await (0, exports.runGit)({ cwd, repo }, gitArguments);
+    return done.code === 0 ? (0, exports.stdoutText)(done) : undefined;
+};
+exports.git = git;
+const realPath = async (target) => {
+    try {
+        return await (0, promises_1.realpath)(target);
+    }
+    catch {
+        return target;
+    }
+};
+const commonDirectory = async (cwd, repo) => {
+    const out = await (0, exports.git)(cwd, repo, ['rev-parse', '--git-common-dir']);
+    return out === undefined ? undefined : realPath(node_path_1.default.resolve(cwd, repo, out.trim()));
+};
+exports.commonDirectory = commonDirectory;
+const batchEntry = (batch, file, position) => {
+    const end = batch.out.indexOf(0x0A, position);
+    const header = batch.out.subarray(position, end).toString('utf8')
+        .split(' ');
+    if (header.at(-1) === 'missing') {
+        throw new config_js_1.ConfigError(`в ${batch.describe}:${file}`);
+    }
+    const size = Number(header[2]);
+    return [decoder.decode(batch.out.subarray(end + 1, end + 1 + size)), end + 1 + size + 1];
+};
+const parseBatch = (batch) => {
+    const texts = new Map();
+    let position = 0;
+    for (const file of batch.files) {
+        const [text, next] = batchEntry(batch, file, position);
+        texts.set(file, text);
+        position = next;
+    }
+    return texts;
+};
+const readAtRevision = async (location, revision, files) => {
+    const done = await (0, exports.runGit)(location, ['cat-file', '--batch'], files.map((file) => `${revision}:${file}\n`).join(''));
+    if (done.code !== 0) {
+        throw new config_js_1.ConfigError(`git cat-file в ${location.repo} на ${revision} не прошёл: ${done.stderr.trim()}`);
+    }
+    return parseBatch({ describe: `${location.repo} нет ${revision}`, files, out: done.stdout });
+};
+exports.readAtRevision = readAtRevision;

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

@@ -0,0 +1,27 @@
+export * from './acceptance-class.js';
+export * from './board.js';
+export * from './classes.js';
+export * from './classify.js';
+export * from './config.js';
+export * from './coverage.js';
+export * from './coverage-data.js';
+export * from './coverage-json.js';
+export * from './coverage-open.js';
+export * from './coverage-page.js';
+export * from './coverage-removed.js';
+export * from './dates.js';
+export * from './declared.js';
+export * from './features.js';
+export * from './gherkin.js';
+export * from './git.js';
+export * from './inventory.js';
+export * from './links.js';
+export * from './lint.js';
+export * from './lint-inputs.js';
+export * from './projects.js';
+export * from './python-text.js';
+export * from './remote.js';
+export * from './removed-list.js';
+export * from './report.js';
+export * from './run.js';
+export * from './task-links.js';

package/dist/cjs/scenarios/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./acceptance-class.js"), exports);
+__exportStar(require("./board.js"), exports);
+__exportStar(require("./classes.js"), exports);
+__exportStar(require("./classify.js"), exports);
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./coverage.js"), exports);
+__exportStar(require("./coverage-data.js"), exports);
+__exportStar(require("./coverage-json.js"), exports);
+__exportStar(require("./coverage-open.js"), exports);
+__exportStar(require("./coverage-page.js"), exports);
+__exportStar(require("./coverage-removed.js"), exports);
+__exportStar(require("./dates.js"), exports);
+__exportStar(require("./declared.js"), exports);
+__exportStar(require("./features.js"), exports);
+__exportStar(require("./gherkin.js"), exports);
+__exportStar(require("./git.js"), exports);
+__exportStar(require("./inventory.js"), exports);
+__exportStar(require("./links.js"), exports);
+__exportStar(require("./lint.js"), exports);
+__exportStar(require("./lint-inputs.js"), exports);
+__exportStar(require("./projects.js"), exports);
+__exportStar(require("./python-text.js"), exports);
+__exportStar(require("./remote.js"), exports);
+__exportStar(require("./removed-list.js"), exports);
+__exportStar(require("./report.js"), exports);
+__exportStar(require("./run.js"), exports);
+__exportStar(require("./task-links.js"), exports);

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

@@ -0,0 +1,8 @@
+import type { ConfigInterface } from './config.js';
+import type { ReportInterface } from './report.js';
+export declare const inventoryContract = 1;
+export interface InventoryOptionsInterface {
+    readonly out: string;
+    readonly stories: readonly string[];
+}
+export declare const inventoryCommand: (cwd: string, config: ConfigInterface, options: InventoryOptionsInterface) => Promise<ReportInterface>;

package/dist/cjs/scenarios/inventory.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inventoryCommand = exports.inventoryContract = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const acceptance_class_js_1 = require("./acceptance-class.js");
+const config_js_1 = require("./config.js");
+const features_js_1 = require("./features.js");
+const gherkin_js_1 = require("./gherkin.js");
+const python_text_js_1 = require("./python-text.js");
+const removed_list_js_1 = require("./removed-list.js");
+exports.inventoryContract = 1;
+const fieldJson = (field) => ({
+    kinds: field.kinds,
+    line: field.line,
+    problem: field.problem ?? null,
+    reason: field.reason,
+});
+const storyFields = async (cwd, file) => {
+    try {
+        return { fields: (0, acceptance_class_js_1.acceptanceFields)(await (0, features_js_1.readText)(cwd, file)), file };
+    }
+    catch (error) {
+        throw new config_js_1.ConfigError(`story ${file} не читается: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const filesJson = (files) => [...files]
+    .map(([file, text]) => ({ language: (0, gherkin_js_1.featureLanguage)(text), path: file, tags: (0, gherkin_js_1.featureTags)(text) }));
+const inventoryCommand = async (cwd, config, options) => {
+    const files = await (0, features_js_1.worktreeFeatures)(cwd, config);
+    const scenarios = (0, features_js_1.allScenarios)(files);
+    const removed = await (0, removed_list_js_1.parseRemoved)(cwd, config.removed);
+    const stories = await Promise.all(options.stories.map(async (file) => storyFields(cwd, file)));
+    const inventory = {
+        config: { features: config.features, groups: config.groups, id: config.id.source, removed: config.removed },
+        contract: exports.inventoryContract,
+        files: filesJson(files),
+        removed: [...removed.entries].map(([id, line]) => ({ id, line })),
+        scenarios: scenarios.map((scenario) => ({ ...scenario, ids: scenario.tags.filter((tag) => config.id.test(tag)) })),
+        stories: stories.map((story) => ({ fields: story.fields.map((field) => fieldJson(field)), file: story.file })),
+    };
+    const target = node_path_1.default.resolve(cwd, options.out);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+    await (0, promises_1.writeFile)(target, `${JSON.stringify(inventory, undefined, 2)}\n`);
+    return {
+        defects: [],
+        notes: [],
+        summary: `инвентарь: feature-файлов ${files.size}, сценариев ${scenarios.length}, снятых ${removed.entries.size}, `
+            + `story ${stories.length} → ${options.out}`,
+    };
+};
+exports.inventoryCommand = inventoryCommand;

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

@@ -0,0 +1,4 @@
+import type { ConfigInterface } from './config.js';
+import type { ProjectsInputInterface } from './projects.js';
+import type { ReportInterface } from './report.js';
+export declare const linksCommand: (config: ConfigInterface, input: ProjectsInputInterface) => Promise<ReportInterface>;

package/dist/cjs/scenarios/links.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linksCommand = void 0;
+const config_js_1 = require("./config.js");
+const features_js_1 = require("./features.js");
+const gherkin_js_1 = require("./gherkin.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 wideFirst = new Set(['*', '\\', '<']);
+const wideAfter = new Set(['.*', '.<']);
+const templateStory = (tag) => {
+    const dot = tag.lastIndexOf('.');
+    return dot === -1 ? tag : tag.slice(0, dot);
+};
+const storyWide = (config, link) => {
+    if (!config.id.test(link.tag)) {
+        return ['шаблон вместо номера', templateStory(link.tag)];
+    }
+    const isWhole = wideFirst.has(link.after.slice(0, 1)) || wideAfter.has(link.after);
+    return isWhole ? ['story целиком', link.tag] : undefined;
+};
+const problemOutcome = (link, problem) => (link.isClosed
+    ? { defect: `ссылка из закрытой story никуда не ведёт (${problem}): @${link.tag} — ${link.location}` }
+    : { todo: `завести: @${link.tag} — ${link.location} (${problem}, story ${link.status || 'вне board'})` });
+const liveOutcome = (link, owner) => {
+    if (owner.tags.includes(config_js_1.markTodo)) {
+        return { debt: link };
+    }
+    const isPendingClosed = link.isClosed && owner.tags.includes(config_js_1.markPending);
+    const defect = `закрытая story ссылается на сценарий «ждёт реализации» @${link.tag}: ${link.location} → ${(0, gherkin_js_1.where)(owner)}`;
+    return isPendingClosed ? { defect } : {};
+};
+const wideOutcome = (known, link, wide) => {
+    const [kind, story] = wide;
+    const hasScenarios = [...known.ids.keys(), ...known.removed.keys()].some((id) => id.startsWith(`${story}.`));
+    return hasScenarios ? {} : problemOutcome(link, `${kind}, а сценариев этой story нет`);
+};
+const exactOutcome = (known, link) => {
+    const owner = known.ids.get(link.tag)?.[0];
+    if (owner !== undefined) {
+        return liveOutcome(link, owner);
+    }
+    return known.removed.has(link.tag) ? {} : problemOutcome(link, 'сценария нет');
+};
+const outcomeOf = (config, known, link) => {
+    const wide = storyWide(config, link);
+    return wide === undefined ? exactOutcome(known, link) : wideOutcome(known, link, wide);
+};
+const linkOf = (row, match) => {
+    const end = match.index + match[0].length;
+    return {
+        after: row.text.slice(end, end + 2),
+        isClosed: row.status === 'done',
+        location: `${row.project}/${row.file}:${row.line}`,
+        status: row.status,
+        tag: match[0].slice(1),
+    };
+};
+const rowLinks = (config, row) => [...row.text.matchAll(task_links_js_1.linkToken)]
+    .filter((match) => (0, config_js_1.isProjectCovered)(config, String(match[1])))
+    .map((match) => linkOf(row, match));
+const summaryOf = (scenarios, counts) => {
+    const pending = (0, features_js_1.countMark)(scenarios, config_js_1.markPending);
+    const quarantine = (0, features_js_1.countMark)(scenarios, config_js_1.markQuarantine);
+    const todo = (0, features_js_1.countMark)(scenarios, config_js_1.markTodo);
+    const tested = `с тестом ${scenarios.length - todo}, из них @${config_js_1.markPending} ${pending}, @${config_js_1.markQuarantine} ${quarantine}`;
+    const links = `ссылок из закрытых story ${counts.closed}, из незакрытых ${counts.open}`;
+    return `прочитано: сценариев ${scenarios.length} (${tested}; долгов @${config_js_1.markTodo} ${todo}), снятых ${counts.removed}; ${links}`;
+};
+const debtLine = (id, owner, references) => `долг: @${id} — ${(0, gherkin_js_1.where)(owner)}; ссылки: ${references.join(', ') || 'нет'}`;
+const debtLines = (known, outcomes) => [...known.ids]
+    .toSorted(([left], [right]) => (0, python_text_js_1.compareText)(left, right))
+    .flatMap(([id, owners]) => owners.slice(0, 1)
+    .filter((owner) => owner.tags.includes(config_js_1.markTodo))
+    .map((owner) => debtLine(id, owner, outcomes.flatMap(({ debt }) => (debt?.tag === id ? [debt.location] : [])))));
+const knownOf = async (config, input, ids) => {
+    const removed = await (0, removed_list_js_1.parseRemoved)(input.cwd, config.removed);
+    return { ids, removed: removed.entries };
+};
+const linksCommand = async (config, input) => {
+    const files = await (0, features_js_1.worktreeFeatures)(input.cwd, config);
+    const known = await knownOf(config, input, (0, features_js_1.scenarioIds)(config, files));
+    const read = await (0, task_links_js_1.readProjects)(input);
+    const links = read.rows.flatMap((row) => rowLinks(config, row));
+    const outcomes = links.map((link) => outcomeOf(config, known, link));
+    const closed = links.filter((link) => link.isClosed).length;
+    const summary = summaryOf((0, features_js_1.allScenarios)(files), { closed, open: links.length - closed, removed: known.removed.size });
+    return {
+        defects: outcomes.flatMap((outcome) => outcome.defect ?? []),
+        notes: read.notes,
+        summary: [
+            `${summary}\nзадачи: ${read.sources.join('; ') || 'нет'}`,
+            ...debtLines(known, outcomes),
+            ...outcomes.flatMap((outcome) => outcome.todo ?? []),
+        ].join('\n'),
+    };
+};
+exports.linksCommand = linksCommand;

package/dist/cjs/scenarios/lint-inputs.d.ts

@@ -0,0 +1,12 @@
+import type { ConfigInterface } from './config.js';
+export interface ListResultInterface {
+    readonly defects: readonly string[];
+    readonly notes: readonly string[];
+    readonly tests: number;
+}
+export interface UnusedResultInterface {
+    readonly count: number;
+    readonly defects: readonly string[];
+}
+export declare const lintList: (config: ConfigInterface, cwd: string, file: string) => Promise<ListResultInterface>;
+export declare const lintUnused: (cwd: string, file: string) => Promise<UnusedResultInterface>;

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

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintUnused = exports.lintList = 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 python_text_js_1 = require("./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 (0, promises_1.readFile)(node_path_1.default.resolve(cwd, file), 'utf8');
+    }
+    catch (error) {
+        throw new config_js_1.ConfigError(`${describe} ${file} не читается: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const readJson = async (cwd, file) => {
+    const text = await readInput(cwd, file, 'список тестов');
+    try {
+        return asRecord(JSON.parse(text));
+    }
+    catch (error) {
+        throw new config_js_1.ConfigError(`список тестов ${file} не читается: ${(0, python_text_js_1.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 (0, python_text_js_1.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 (0, python_text_js_1.sortedText)(config_js_1.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}): ${(0, python_text_js_1.pyText)(spec.title)}`] : [];
+};
+const pendingDefects = (context, spec, project) => {
+    const isStray = project === context.pending && !specTags(spec).includes(config_js_1.markPending);
+    return isStray ? [`проект «${context.pending}» выбирает сценарий без @${config_js_1.markPending}: ${(0, python_text_js_1.pyText)(spec.title)}`] : [];
+};
+const testDefects = (context, spec, test) => {
+    const project = (0, python_text_js_1.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) => (0, python_text_js_1.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 config_js_1.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)]));
+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,
+    };
+};
+exports.lintList = lintList;
+const unusedRowOf = (line) => {
+    const groups = unusedRow.exec(line)?.groups;
+    return groups === undefined ? [] : [[String(groups.pattern), String(groups.location)]];
+};
+const duplicateSteps = (rows) => (0, python_text_js_1.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 config_js_1.ConfigError(`в ${file} нет строки «Unused steps (N)» — формат вывода bddgen сменился`);
+    }
+    return Number(groups.count);
+};
+const lintUnused = async (cwd, file) => {
+    const text = await readInput(cwd, file, 'вывод неиспользуемых шагов');
+    const declared = declaredCount(text, file);
+    const rows = (0, python_text_js_1.splitLines)(text).flatMap((line) => unusedRowOf(line));
+    if (rows.length !== declared) {
+        throw new config_js_1.ConfigError(`bddgen объявил ${declared} неиспользуемых шагов, разобрано ${rows.length} — формат вывода сменился`);
+    }
+    const unused = rows.map(([pattern, location]) => `неиспользуемый шаг «${pattern}»: ${location}`);
+    return { count: rows.length, defects: [...unused, ...duplicateSteps(rows)] };
+};
+exports.lintUnused = lintUnused;

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

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