@application-kit/acceptance 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @application-kit/acceptance
+
+## 0.1.1
+
+### Patch Changes
+
+- 8458cb7: `classes` и `links` видят story продукта, когда репозиторий тестов — его подкаталог: задачи читаются с коммита текущего checkout. Сценарии критериев старого формата `AC-22.10.` засчитываются своей story.
+
+## 0.1.0
+
+### Minor Changes
+
+- 572f086: Новый пакет: команда `application-scenarios` для репозитория приёмочных тестов (`lint`, `removed`, `links`, `classes`, `coverage`, `inventory`), каденс прогона, реестр окружений и чтение учётных данных окружения. Вывод `inventory` несёт версию контракта `contract`.

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

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

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

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_process_1 = __importDefault(require("node:process"));
+const run_js_1 = require("../scenarios/run.js");
+const main = async () => {
+    const result = await (0, run_js_1.runScenarios)(node_process_1.default.argv.slice(2), { cwd: node_process_1.default.cwd(), now: new Date() });
+    node_process_1.default.stdout.write(result.stdout);
+    node_process_1.default.stderr.write(result.stderr);
+    node_process_1.default.exitCode = result.code;
+};
+void main();

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

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

package/dist/cjs/bin/index.js

@@ -0,0 +1,17 @@
+"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("./application-scenarios.js"), exports);

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

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

package/dist/cjs/cadence/index.js

@@ -0,0 +1,17 @@
+"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("./resolve-cadence.js"), exports);

package/dist/cjs/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/cjs/cadence/resolve-cadence.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCadence = void 0;
+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];
+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;
+};
+exports.resolveCadence = resolveCadence;

package/dist/cjs/environments/environment.interface.d.ts

@@ -0,0 +1,5 @@
+export interface EnvironmentInterface {
+    readonly admissionTag?: string;
+    readonly name: string;
+    readonly secretsPrefix: string;
+}

package/dist/cjs/environments/environment.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+export * from './environment.interface.js';
+export * from './resolve-environment.js';
+export * from './secrets.js';

package/dist/cjs/environments/index.js

@@ -0,0 +1,19 @@
+"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("./environment.interface.js"), exports);
+__exportStar(require("./resolve-environment.js"), exports);
+__exportStar(require("./secrets.js"), exports);

package/dist/cjs/environments/resolve-environment.d.ts

@@ -0,0 +1,10 @@
+import type { EnvironmentInterface } from './environment.interface.js';
+export interface EnvironmentRegistryInterface {
+    readonly environments: readonly EnvironmentInterface[];
+    readonly fallback: string;
+}
+export interface ResolvedEnvironmentInterface extends EnvironmentInterface {
+    readonly baseUrl: string | undefined;
+}
+export type VariablesType = Readonly<Record<string, string | undefined>>;
+export declare const resolveEnvironment: (registry: EnvironmentRegistryInterface, variables: VariablesType) => ResolvedEnvironmentInterface;

package/dist/cjs/environments/resolve-environment.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnvironment = void 0;
+const findEnvironment = (registry, name) => {
+    const environment = registry.environments.find((candidate) => candidate.name === name);
+    if (environment === undefined) {
+        const known = registry.environments.map((candidate) => candidate.name).join(', ');
+        throw new Error(`ACCEPTANCE_ENV: окружения «${name}» нет в реестре (есть: ${known})`);
+    }
+    return environment;
+};
+const baseUrlOf = (variables) => {
+    const baseUrl = variables.ACCEPTANCE_BASE_URL ?? '';
+    return baseUrl === '' ? undefined : new URL(baseUrl).href;
+};
+const resolveEnvironment = (registry, variables) => {
+    const environment = findEnvironment(registry, variables.ACCEPTANCE_ENV ?? registry.fallback);
+    return { ...environment, baseUrl: baseUrlOf(variables) };
+};
+exports.resolveEnvironment = resolveEnvironment;

package/dist/cjs/environments/secrets.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentInterface } from './environment.interface.js';
+import type { VariablesType } from './resolve-environment.js';
+export declare const secretVariable: (environment: EnvironmentInterface, name: string) => string;
+export declare const readSecret: (environment: EnvironmentInterface, name: string, variables: VariablesType) => string;

package/dist/cjs/environments/secrets.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSecret = exports.secretVariable = void 0;
+const secretVariable = (environment, name) => `${environment.secretsPrefix}${name}`;
+exports.secretVariable = secretVariable;
+const readSecret = (environment, name, variables) => {
+    const variable = (0, exports.secretVariable)(environment, name);
+    const value = variables[variable] ?? '';
+    if (value === '') {
+        throw new Error(`${variable}: переменная с учётными данными не задана`);
+    }
+    return value;
+};
+exports.readSecret = readSecret;

package/dist/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cadence/index.js';
+export * from './environments/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"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("./cadence/index.js"), exports);
+__exportStar(require("./environments/index.js"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/scenarios/acceptance-class.d.ts

@@ -0,0 +1,26 @@
+import type { ConfigInterface } from './config.js';
+import type { ScenarioInterface } from './gherkin.js';
+export interface AcceptanceFieldInterface {
+    readonly kind: string;
+    readonly kinds: readonly AcceptanceKindType[];
+    readonly line: number;
+    readonly problem: string | undefined;
+    readonly reason: string;
+}
+export type AcceptanceKindType = (typeof acceptanceKinds)[number];
+export type ScenarioStateType = 'без сценария' | 'все сняты' | 'с тестом' | 'только долг';
+export interface StoryClassInterface {
+    readonly defects: readonly string[];
+    readonly kinds: readonly AcceptanceKindType[] | undefined;
+}
+export interface StoryInputInterface {
+    readonly config: ConfigInterface;
+    readonly location: string;
+    readonly text: string;
+}
+declare const acceptanceKinds: readonly ["e2e", "code-tests", "none"];
+export declare const acceptanceFields: (text: string) => AcceptanceFieldInterface[];
+export declare const storyLinks: (text: string, config: ConfigInterface) => (readonly [number, string])[];
+export declare const storyClass: (input: StoryInputInterface) => StoryClassInterface;
+export declare const scenarioState: (storyIds: readonly string[], ids: ReadonlyMap<string, readonly ScenarioInterface[]>, removed: ReadonlyMap<string, number>) => ScenarioStateType;
+export {};

package/dist/cjs/scenarios/acceptance-class.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scenarioState = exports.storyClass = exports.storyLinks = exports.acceptanceFields = void 0;
+const config_js_1 = require("./config.js");
+const python_text_js_1 = require("./python-text.js");
+const task_links_js_1 = require("./task-links.js");
+const acceptanceField = /\*\*Acceptance tests:\*\*[\t ]*(?<value>.*?)(?=\s+·\s+\*\*|$)/gu;
+const acceptanceKinds = ['e2e', 'code-tests', 'none'];
+const legacyKinds = {
+    'n/a': 'none',
+    ниже: 'code-tests',
+    сценарий: 'e2e',
+};
+const kindNames = acceptanceKinds;
+const isKind = (name) => kindNames.includes(name);
+const partition = (text, separator) => {
+    const index = text.indexOf(separator);
+    return index === -1 ? [text, ''] : [text.slice(0, index), text.slice(index + separator.length)];
+};
+const namesOf = (kindPart) => kindPart.split(',').map((name) => name.trim());
+const setProblem = (kindPart, kinds) => {
+    const field = `\`**Acceptance tests:** ${kindPart}\``;
+    if (new Set(kinds).size < kinds.length) {
+        return `${field}: класс в наборе дважды`;
+    }
+    return kinds.includes('none') && kinds.length > 1 ? `${field}: none в наборе с другим классом` : undefined;
+};
+const nameProblem = (kindPart, names, value) => {
+    for (const name of names) {
+        const renamed = legacyKinds[name];
+        if (renamed !== undefined) {
+            return `\`**Acceptance tests:** ${kindPart}\`: старое имя класса ${name} — теперь ${renamed}`;
+        }
+    }
+    if (names.every((name) => isKind(name))) {
+        return undefined;
+    }
+    const shown = (0, python_text_js_1.pyRepr)([...value].slice(0, 60).join(''));
+    return `\`**Acceptance tests:**\` вне набора ${acceptanceKinds.join(' | ')} (через запятую): ${shown}`;
+};
+const reasonProblem = (kindPart, kinds, reason) => {
+    const isUnexplained = kinds.some((kind) => kind !== 'e2e') && reason === '';
+    return isUnexplained ? `\`**Acceptance tests:** ${kindPart}\` без причины после тире` : undefined;
+};
+const problemOf = (kindPart, reason, value) => {
+    const names = namesOf(kindPart);
+    return nameProblem(kindPart, names, value) ?? reasonProblem(kindPart, names, reason) ?? setProblem(kindPart, names);
+};
+const fieldOf = (rawValue, line) => {
+    const value = rawValue.trim();
+    const [kindPart, reasonPart] = partition(value, '—');
+    const kind = kindPart.trim();
+    const reason = reasonPart.trim();
+    const problem = problemOf(kind, reason, value);
+    const kinds = problem === undefined ? namesOf(kind).filter((name) => isKind(name)) : [];
+    return { kind, kinds, line, problem, reason };
+};
+const lineFields = (line, index) => [...line.matchAll(acceptanceField)]
+    .map((match) => fieldOf(match.groups?.value ?? '', index + 1));
+const acceptanceFields = (text) => {
+    const [header] = partition(text, '\n## ');
+    return (0, python_text_js_1.splitLines)(header).flatMap((line, index) => lineFields(line, index));
+};
+exports.acceptanceFields = acceptanceFields;
+const storyLinks = (text, config) => (0, python_text_js_1.splitLines)(text)
+    .flatMap((line, index) => [...line.matchAll(task_links_js_1.linkToken)]
+    .filter((match) => (0, config_js_1.isProjectCovered)(config, match.groups?.project ?? ''))
+    .map((match) => [index + 1, match[0].slice(1)]));
+exports.storyLinks = storyLinks;
+const repeatedField = (fields, line, location) => {
+    const lines = fields.map((item) => String(item.line)).join(', ');
+    return `поле \`**Acceptance tests:**\` в шапке ${fields.length} раза (строки ${lines}): ${location}:${line}`;
+};
+const contradiction = (input, field) => {
+    const [link] = (0, exports.storyLinks)(input.text, input.config);
+    return link === undefined || field.kinds.includes('e2e') ? [] : [`класс ${field.kind}, а story ссылается на сценарий @${link[1]}: ${input.location}:${link[0]}`];
+};
+const classOf = (input, field) => (field.problem === undefined ? { defects: contradiction(input, field), kinds: field.kinds } : { defects: [`${field.problem}: ${input.location}:${field.line}`], kinds: undefined });
+const storyClass = (input) => {
+    const fields = (0, exports.acceptanceFields)(input.text);
+    const [field, second] = fields;
+    if (field === undefined) {
+        return { defects: [`закрытая story без поля \`**Acceptance tests:**\`: ${input.location}`], kinds: undefined };
+    }
+    return second === undefined
+        ? classOf(input, field)
+        : { defects: [repeatedField(fields, second.line, input.location)], kinds: undefined };
+};
+exports.storyClass = storyClass;
+const scenarioState = (storyIds, ids, removed) => {
+    const alive = storyIds.filter((id) => !removed.has(id)).flatMap((id) => ids.get(id)?.slice(0, 1) ?? []);
+    if (alive.some((scenario) => !scenario.tags.includes(config_js_1.markTodo))) {
+        return 'с тестом';
+    }
+    if (alive.length > 0) {
+        return 'только долг';
+    }
+    return storyIds.some((id) => removed.has(id)) ? 'все сняты' : 'без сценария';
+};
+exports.scenarioState = scenarioState;

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

@@ -0,0 +1,6 @@
+type RecordType = Readonly<Record<string, unknown>>;
+export declare const acceptanceKey = "acceptance_tests";
+export declare const isRecord: (value: unknown) => value is RecordType;
+export declare const parseBoard: (text: string) => unknown;
+export declare const boardStatuses: (text: string, where: string) => Map<string, string>;
+export {};

package/dist/cjs/scenarios/board.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boardStatuses = exports.parseBoard = exports.isRecord = exports.acceptanceKey = void 0;
+const yaml_1 = require("yaml");
+const config_js_1 = require("./config.js");
+const python_text_js_1 = require("./python-text.js");
+const boardFormat = 6;
+const epicFields = new Set(['retro', 'status', 'tasks', 'version']);
+const legacyStatuses = {
+    contexted: 'in_progress',
+    drafted: 'ready',
+    'in-progress': 'in_progress',
+    'ready-for-dev': 'ready',
+};
+const epicKey = /^epic-\d+[a-z]?$/u;
+const integer = /^[+-]?\d+$/u;
+const yamlLogLevel = 'error';
+exports.acceptanceKey = 'acceptance_tests';
+const isRecord = (value) => {
+    const isObject = typeof value === 'object' && value !== null;
+    return isObject && !Array.isArray(value);
+};
+exports.isRecord = isRecord;
+const parseBoard = (text) => (0, yaml_1.parse)(text, {
+    logLevel: yamlLogLevel,
+    maxAliasCount: -1,
+    uniqueKeys: false,
+    version: '1.1',
+});
+exports.parseBoard = parseBoard;
+const isMissing = (value) => value === undefined || value === null;
+const formatOf = (data, where) => {
+    const raw = isMissing(data.version) ? data.board_format : data.version;
+    const text = isMissing(raw) ? '1' : (0, python_text_js_1.pyText)(raw).trim();
+    if (!integer.test(text)) {
+        throw new config_js_1.ConfigError(`board ${where}: version: ${text} — ожидалось целое число версии формата`);
+    }
+    return Number(text);
+};
+const normalize = (value) => {
+    const status = (0, python_text_js_1.pyText)(value);
+    return legacyStatuses[status] ?? status;
+};
+const statusField = (value) => ('status' in value ? value.status : 'backlog');
+const taskStatus = (value) => normalize((0, exports.isRecord)(value) ? statusField(value) : value);
+const isEpicBlock = (block) => {
+    const keys = (0, exports.isRecord)(block) ? Object.keys(block) : undefined;
+    return keys?.every((key) => epicFields.has(key)) === true;
+};
+const tasksOf = (epic, block, where) => {
+    const tasks = block.tasks ?? {};
+    if (!(0, exports.isRecord)(tasks)) {
+        throw new config_js_1.ConfigError(`board ${where}: development_status[${epic}].tasks — ожидался маппинг задач`);
+    }
+    return tasks;
+};
+const epicTasks = (epic, block, where) => {
+    if (isMissing(block)) {
+        return {};
+    }
+    if (!isEpicBlock(block)) {
+        throw new config_js_1.ConfigError(`board ${where}: development_status[${epic}] — не блок эпика формата ${boardFormat}`);
+    }
+    return tasksOf(epic, block, where);
+};
+const isStory = (key) => !key.endsWith('-retrospective') && !epicKey.test(key);
+const parseOrFail = (text, where) => {
+    try {
+        return (0, exports.parseBoard)(text) ?? {};
+    }
+    catch (error) {
+        throw new config_js_1.ConfigError(`board ${where}: невалидный YAML: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const loadBoard = (text, where) => {
+    const data = parseOrFail(text, where);
+    if (!(0, exports.isRecord)(data)) {
+        throw new config_js_1.ConfigError(`board ${where}: ожидался маппинг`);
+    }
+    return data;
+};
+const epicsOf = (data, where) => {
+    const format = formatOf(data, where);
+    if (format !== boardFormat) {
+        throw new config_js_1.ConfigError(`board ${where}: формат ${format}, инструмент понимает ${boardFormat}`);
+    }
+    const epics = data.development_status ?? {};
+    if (!(0, exports.isRecord)(epics)) {
+        throw new config_js_1.ConfigError(`board ${where}: development_status — ожидался маппинг эпиков`);
+    }
+    return epics;
+};
+const boardStatuses = (text, where) => {
+    const epics = epicsOf(loadBoard(text, where), where);
+    const tasks = Object.entries(epics).flatMap(([epic, block]) => Object.entries(epicTasks(epic, block, where)));
+    return new Map(tasks.filter(([key]) => isStory(key)).map(([key, value]) => [key, taskStatus(value)]));
+};
+exports.boardStatuses = boardStatuses;

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

@@ -0,0 +1,16 @@
+import type { ClassificationInterface, ScenariosInterface } from './classify.js';
+import type { DeclaredInputInterface } from './declared.js';
+import type { ProjectInterface } from './projects.js';
+import type { ReportInterface } from './report.js';
+export interface ClassifiedAllInterface {
+    readonly classified: readonly ClassifiedInterface[];
+    readonly defects: readonly string[];
+    readonly notes: readonly string[];
+}
+export interface ClassifiedInterface extends ClassificationInterface {
+    readonly project: ProjectInterface;
+}
+export declare const noProjects = "\u043F\u0440\u043E\u0435\u043A\u0442\u043E\u0432, \u0447\u0435\u0439 board \u043E\u0431\u044A\u044F\u0432\u043B\u044F\u0435\u0442 \u044D\u0442\u043E\u0442 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439, \u043D\u0435\u0442";
+export declare const classifyDeclared: (scenarios: ScenariosInterface, input: DeclaredInputInterface) => Promise<ClassifiedAllInterface>;
+export declare const sourcesLine: (projects: readonly ProjectInterface[]) => string;
+export declare const classesCommand: (input: DeclaredInputInterface, isListed: boolean) => Promise<ReportInterface>;

package/dist/cjs/scenarios/classes.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classesCommand = exports.sourcesLine = exports.classifyDeclared = exports.noProjects = void 0;
+const classify_js_1 = require("./classify.js");
+const config_js_1 = require("./config.js");
+const declared_js_1 = require("./declared.js");
+const features_js_1 = require("./features.js");
+const projects_js_1 = require("./projects.js");
+const removed_list_js_1 = require("./removed-list.js");
+exports.noProjects = 'проектов, чей board объявляет этот репозиторий, нет';
+const readScenarios = async (input) => {
+    const files = await (0, features_js_1.worktreeFeatures)(input.cwd, input.config);
+    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 classifyProject = async (scenarios, project) => {
+    const classification = await (0, classify_js_1.classify)(scenarios, project);
+    return { ...classification, project };
+};
+const classifyDeclared = async (scenarios, input) => {
+    const { declared, notes } = await (0, declared_js_1.declaredProjects)(input);
+    const results = await Promise.all(declared.map(async ({ defect, project }) => {
+        const item = await classifyProject(scenarios, project);
+        return { defects: [defect ?? [], item.defects].flat(), item };
+    }));
+    return { classified: results.map(({ item }) => item), defects: results.flatMap(({ defects }) => defects), notes };
+};
+exports.classifyDeclared = classifyDeclared;
+const projectLine = ({ closed, counts, project }) => {
+    const e2e = `e2e ${counts.e2e} (с тестом ${counts['с тестом']}, только долг @${config_js_1.markTodo} `
+        + `${counts['только долг']}, все сняты ${counts['все сняты']}, без сценария ${counts['без сценария']})`;
+    const others = `code-tests ${counts['code-tests']}, none ${counts.none}, без класса ${counts['без класса']}`;
+    return `${project.name} — закрытых ${closed}: ${e2e}, ${others}, знаменатель покрытия ${counts.e2e - counts['все сняты']}`;
+};
+const sourcesLine = (projects) => {
+    const sources = projects.map((project) => (0, projects_js_1.sourceOf)(project)).join('; ');
+    return `задачи: ${sources || 'нет'}`;
+};
+exports.sourcesLine = sourcesLine;
+const classesCommand = async (input, isListed) => {
+    const scenarios = await readScenarios(input);
+    const { classified, defects, notes } = await (0, exports.classifyDeclared)(scenarios, input);
+    const parts = classified.map((item) => projectLine(item)).join(' · ');
+    const transfers = isListed ? classified.flatMap((item) => item.transfers) : [];
+    const summary = [`классы закрытых story: ${parts || exports.noProjects}`, (0, exports.sourcesLine)(classified.map((item) => item.project))];
+    return { defects, notes, summary: [...summary, ...transfers].join('\n') };
+};
+exports.classesCommand = classesCommand;

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

@@ -0,0 +1,35 @@
+import type { AcceptanceKindType, ScenarioStateType } from './acceptance-class.js';
+import type { ConfigInterface } from './config.js';
+import type { ScenarioInterface } from './gherkin.js';
+import type { ProjectInterface } from './projects.js';
+export interface ClassificationInterface {
+    readonly closed: number;
+    readonly counts: CountsType;
+    readonly defects: readonly string[];
+    readonly open: readonly OpenStoryInterface[];
+    readonly stories: readonly ScenarioStoryInterface[];
+    readonly transfers: readonly string[];
+}
+export interface OpenStoryInterface {
+    readonly file: string | undefined;
+    readonly ids: readonly string[];
+    readonly key: string;
+    readonly kinds: readonly AcceptanceKindType[] | undefined;
+    readonly status: string;
+}
+export interface ScenariosInterface {
+    readonly config: ConfigInterface;
+    readonly cwd: string;
+    readonly ids: ReadonlyMap<string, readonly ScenarioInterface[]>;
+    readonly removed: ReadonlyMap<string, number>;
+}
+export interface ScenarioStoryInterface {
+    readonly file: string;
+    readonly ids: readonly string[];
+    readonly key: string;
+    readonly state: ScenarioStateType;
+}
+type CountsType = Readonly<Record<CountType, number>>;
+type CountType = 'без класса' | AcceptanceKindType | ScenarioStateType;
+export declare const classify: (scenarios: ScenariosInterface, project: ProjectInterface) => Promise<ClassificationInterface>;
+export {};