@application-kit/acceptance 0.0.0-stage → 0.1.0

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

package/dist/esm/environments/index.js

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

package/dist/esm/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/esm/environments/resolve-environment.js

@@ -0,0 +1,16 @@
+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;
+};
+export const resolveEnvironment = (registry, variables) => {
+    const environment = findEnvironment(registry, variables.ACCEPTANCE_ENV ?? registry.fallback);
+    return { ...environment, baseUrl: baseUrlOf(variables) };
+};

package/dist/esm/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/esm/environments/secrets.js

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

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

package/dist/esm/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/esm/scenarios/acceptance-class.js

@@ -0,0 +1,93 @@
+import { isProjectCovered, markTodo } from './config.js';
+import { pyRepr, splitLines } from './python-text.js';
+import { linkToken } from './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 = 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));
+export const acceptanceFields = (text) => {
+    const [header] = partition(text, '\n## ');
+    return splitLines(header).flatMap((line, index) => lineFields(line, index));
+};
+export const storyLinks = (text, config) => splitLines(text)
+    .flatMap((line, index) => [...line.matchAll(linkToken)]
+    .filter((match) => isProjectCovered(config, match.groups?.project ?? ''))
+    .map((match) => [index + 1, match[0].slice(1)]));
+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] = 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 });
+export const storyClass = (input) => {
+    const fields = 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 };
+};
+export 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(markTodo))) {
+        return 'с тестом';
+    }
+    if (alive.length > 0) {
+        return 'только долг';
+    }
+    return storyIds.some((id) => removed.has(id)) ? 'все сняты' : 'без сценария';
+};

package/dist/esm/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/esm/scenarios/board.js

@@ -0,0 +1,92 @@
+import { parse } from 'yaml';
+import { ConfigError } from './config.js';
+import { messageOf, pyText } from './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';
+export const acceptanceKey = 'acceptance_tests';
+export const isRecord = (value) => {
+    const isObject = typeof value === 'object' && value !== null;
+    return isObject && !Array.isArray(value);
+};
+export const parseBoard = (text) => parse(text, {
+    logLevel: yamlLogLevel,
+    maxAliasCount: -1,
+    uniqueKeys: false,
+    version: '1.1',
+});
+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' : pyText(raw).trim();
+    if (!integer.test(text)) {
+        throw new ConfigError(`board ${where}: version: ${text} — ожидалось целое число версии формата`);
+    }
+    return Number(text);
+};
+const normalize = (value) => {
+    const status = pyText(value);
+    return legacyStatuses[status] ?? status;
+};
+const statusField = (value) => ('status' in value ? value.status : 'backlog');
+const taskStatus = (value) => normalize(isRecord(value) ? statusField(value) : value);
+const isEpicBlock = (block) => {
+    const keys = isRecord(block) ? Object.keys(block) : undefined;
+    return keys?.every((key) => epicFields.has(key)) === true;
+};
+const tasksOf = (epic, block, where) => {
+    const tasks = block.tasks ?? {};
+    if (!isRecord(tasks)) {
+        throw new ConfigError(`board ${where}: development_status[${epic}].tasks — ожидался маппинг задач`);
+    }
+    return tasks;
+};
+const epicTasks = (epic, block, where) => {
+    if (isMissing(block)) {
+        return {};
+    }
+    if (!isEpicBlock(block)) {
+        throw new 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 parseBoard(text) ?? {};
+    }
+    catch (error) {
+        throw new ConfigError(`board ${where}: невалидный YAML: ${messageOf(error)}`);
+    }
+};
+const loadBoard = (text, where) => {
+    const data = parseOrFail(text, where);
+    if (!isRecord(data)) {
+        throw new ConfigError(`board ${where}: ожидался маппинг`);
+    }
+    return data;
+};
+const epicsOf = (data, where) => {
+    const format = formatOf(data, where);
+    if (format !== boardFormat) {
+        throw new ConfigError(`board ${where}: формат ${format}, инструмент понимает ${boardFormat}`);
+    }
+    const epics = data.development_status ?? {};
+    if (!isRecord(epics)) {
+        throw new ConfigError(`board ${where}: development_status — ожидался маппинг эпиков`);
+    }
+    return epics;
+};
+export 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)]));
+};

package/dist/esm/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/esm/scenarios/classes.js

@@ -0,0 +1,42 @@
+import { classify } from './classify.js';
+import { markTodo } from './config.js';
+import { declaredProjects } from './declared.js';
+import { scenarioIds, worktreeFeatures } from './features.js';
+import { sourceOf } from './projects.js';
+import { parseRemoved } from './removed-list.js';
+export const noProjects = 'проектов, чей board объявляет этот репозиторий, нет';
+const readScenarios = async (input) => {
+    const files = await worktreeFeatures(input.cwd, input.config);
+    const removed = await parseRemoved(input.cwd, input.config.removed);
+    return { config: input.config, cwd: input.cwd, ids: scenarioIds(input.config, files), removed: removed.entries };
+};
+const classifyProject = async (scenarios, project) => {
+    const classification = await classify(scenarios, project);
+    return { ...classification, project };
+};
+export const classifyDeclared = async (scenarios, input) => {
+    const { declared, notes } = await 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 };
+};
+const projectLine = ({ closed, counts, project }) => {
+    const e2e = `e2e ${counts.e2e} (с тестом ${counts['с тестом']}, только долг @${markTodo} `
+        + `${counts['только долг']}, все сняты ${counts['все сняты']}, без сценария ${counts['без сценария']})`;
+    const others = `code-tests ${counts['code-tests']}, none ${counts.none}, без класса ${counts['без класса']}`;
+    return `${project.name} — закрытых ${closed}: ${e2e}, ${others}, знаменатель покрытия ${counts.e2e - counts['все сняты']}`;
+};
+export const sourcesLine = (projects) => {
+    const sources = projects.map((project) => sourceOf(project)).join('; ');
+    return `задачи: ${sources || 'нет'}`;
+};
+export const classesCommand = async (input, isListed) => {
+    const scenarios = await readScenarios(input);
+    const { classified, defects, notes } = await classifyDeclared(scenarios, input);
+    const parts = classified.map((item) => projectLine(item)).join(' · ');
+    const transfers = isListed ? classified.flatMap((item) => item.transfers) : [];
+    const summary = [`классы закрытых story: ${parts || noProjects}`, sourcesLine(classified.map((item) => item.project))];
+    return { defects, notes, summary: [...summary, ...transfers].join('\n') };
+};

package/dist/esm/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 {};

package/dist/esm/scenarios/classify.js

@@ -0,0 +1,104 @@
+import { scenarioState, storyClass, storyLinks } from './acceptance-class.js';
+import { ConfigError } from './config.js';
+import { git, readAtRevision } from './git.js';
+import { projectStatuses, storyKey } from './projects.js';
+import { compareText, sortedText } from './python-text.js';
+const storyNumber = /^(?<epic>\d+[a-z]*)-(?<story>\d+[a-z]*)(?:-|$)/u;
+const revisionStoryFiles = async (cwd, project, revision) => {
+    const listed = await git(cwd, project.repo, ['ls-tree', '-r', '-z', '--name-only', revision, '--', 'tasks']);
+    if (listed === undefined) {
+        throw new ConfigError(`git ls-tree в ${project.repo} на ${project.revision} не прошёл`);
+    }
+    const files = sortedText(listed.split('\0')).filter((file) => file.endsWith('.md'))
+        .toReversed();
+    return new Map(files.map((file) => [storyKey(file), file]));
+};
+const storyPrefix = (story) => {
+    const groups = storyNumber.exec(story.key)?.groups;
+    return groups === undefined ? undefined : `${story.project}:AC-${groups.epic}-${groups.story}.`;
+};
+const storyIds = (scenarios, story) => {
+    const prefix = storyPrefix(story);
+    const linked = storyLinks(story.text, scenarios.config).map(([, tag]) => tag);
+    const known = [...scenarios.ids.keys(), ...scenarios.removed.keys()];
+    const prefixed = prefix === undefined ? [] : known.filter((id) => id.startsWith(prefix));
+    return sortedText(new Set([...linked, ...prefixed]));
+};
+const scenarioOutcome = (scenarios, story, found) => {
+    const ids = storyIds(scenarios, story);
+    const state = scenarioState(ids, scenarios.ids, scenarios.removed);
+    const { defects, kinds } = found;
+    const scenarioStory = { file: story.file, ids, key: story.key, state };
+    return { counted: [...kinds, state], defects, story: scenarioStory };
+};
+const fileOutcome = (scenarios, story) => {
+    const location = `${story.project}/${story.file}`;
+    const found = storyClass({ config: scenarios.config, location, text: story.text });
+    const { defects, kinds } = found;
+    return kinds?.includes('e2e') === true
+        ? scenarioOutcome(scenarios, story, { defects, kinds })
+        : { counted: kinds ?? ['без класса'], defects };
+};
+const isOpen = (status) => status !== 'done' && status !== 'rejected';
+const openStory = (scenarios, story, status) => {
+    const { kinds } = storyClass({ config: scenarios.config, location: story.file, text: story.text });
+    const ids = kinds?.includes('e2e') === true ? storyIds(scenarios, story) : [];
+    return { file: story.file, ids, key: story.key, kinds, status };
+};
+const missingOutcome = (project, key) => ({
+    counted: ['без класса'],
+    defects: [`закрытая story без файла в tasks/ на ${project.revision}: ${project.name}:${key}`],
+});
+const countOf = (outcomes) => {
+    const counted = outcomes.flatMap((outcome) => outcome.counted);
+    const count = (name) => counted.filter((item) => item === name).length;
+    return {
+        'code-tests': count('code-tests'),
+        e2e: count('e2e'),
+        none: count('none'),
+        'без класса': count('без класса'),
+        'без сценария': count('без сценария'),
+        'все сняты': count('все сняты'),
+        'с тестом': count('с тестом'),
+        'только долг': count('только долг'),
+    };
+};
+const transferLines = (project, stories) => stories
+    .filter((story) => story.state === 'без сценария')
+    .map((story) => `перенести: ${project.name}:${story.key} — ${story.file}`);
+const locateStories = async (cwd, project, revision, keys) => {
+    const files = await revisionStoryFiles(cwd, project, revision);
+    const paths = keys.flatMap((key) => files.get(key) ?? []);
+    const texts = await readAtRevision({ cwd, repo: project.repo }, revision, paths);
+    return new Map([...texts].map(([file, text]) => [
+        storyKey(file),
+        { file, key: storyKey(file), project: project.name, text },
+    ]));
+};
+export const classify = async (scenarios, project) => {
+    const statuses = await projectStatuses(scenarios.cwd, project);
+    const revision = String(project.revision);
+    const sorted = [...statuses].toSorted(([left], [right]) => compareText(left, right));
+    const closed = sorted.filter(([, status]) => status === 'done').map(([key]) => key);
+    const open = sorted.filter(([, status]) => isOpen(status));
+    const located = await locateStories(scenarios.cwd, project, revision, [...closed, ...open.map(([key]) => key)]);
+    const outcomes = closed.map((key) => {
+        const story = located.get(key);
+        return story === undefined ? missingOutcome(project, key) : fileOutcome(scenarios, story);
+    });
+    const stories = outcomes.flatMap((outcome) => outcome.story ?? []);
+    const openStories = open.map(([key, status]) => {
+        const story = located.get(key);
+        return story === undefined
+            ? { file: undefined, ids: [], key, kinds: undefined, status }
+            : openStory(scenarios, story, status);
+    });
+    return {
+        closed: closed.length,
+        counts: countOf(outcomes),
+        defects: outcomes.flatMap((outcome) => outcome.defects),
+        open: openStories,
+        stories,
+        transfers: transferLines(project, stories),
+    };
+};

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

@@ -0,0 +1,17 @@
+export interface ConfigInterface {
+    readonly blocking: readonly string[];
+    readonly features: string;
+    readonly groups: readonly string[];
+    readonly id: RegExp;
+    readonly pending: string | undefined;
+    readonly removed: string;
+}
+export declare const markPending = "not-implemented";
+export declare const markQuarantine = "quarantine";
+export declare const markTodo = "todo";
+export declare const marks: readonly string[];
+export declare class ConfigError extends Error {
+    readonly name = "ConfigError";
+}
+export declare const loadConfig: (file: string, cwd: string) => Promise<ConfigInterface>;
+export declare const isProjectCovered: (config: ConfigInterface, project: string) => boolean;

package/dist/esm/scenarios/config.js

@@ -0,0 +1,58 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { messageOf } from './python-text.js';
+export const markPending = 'not-implemented';
+export const markQuarantine = 'quarantine';
+export const markTodo = 'todo';
+export const marks = [markPending, markQuarantine, markTodo];
+export class ConfigError extends Error {
+    name = 'ConfigError';
+}
+const emptyValues = new Set(['', 0, false, null, undefined]);
+const isFilled = (value) => (Array.isArray(value) ? value.length > 0 : !emptyValues.has(value));
+const isRawConfig = (value) => {
+    const isObject = typeof value === 'object' && value !== null;
+    return isObject && !Array.isArray(value);
+};
+const parseRaw = (text) => {
+    const parsed = JSON.parse(text);
+    if (!isRawConfig(parsed)) {
+        throw new TypeError('ждём объект JSON');
+    }
+    return parsed;
+};
+const readRaw = async (file, cwd) => {
+    try {
+        return parseRaw(await readFile(path.resolve(cwd, file), 'utf8'));
+    }
+    catch (error) {
+        throw new ConfigError(`конфиг ${file} не читается: ${messageOf(error)}`);
+    }
+};
+const compileId = (source) => {
+    try {
+        return new RegExp(source, 'u');
+    }
+    catch (error) {
+        throw new ConfigError(`«id» конфига — не regex: ${messageOf(error)}`);
+    }
+};
+const textList = (value) => (Array.isArray(value) ? value.map(String) : []);
+const textOr = (value, fallback) => (typeof value === 'string' ? value : fallback);
+const pendingOf = (value) => (isFilled(value) ? String(value) : undefined);
+export const loadConfig = async (file, cwd) => {
+    const raw = await readRaw(file, cwd);
+    const missing = ['id', 'groups'].find((key) => !isFilled(raw[key]));
+    if (missing !== undefined) {
+        throw new ConfigError(`в конфиге ${file} нет ключа «${missing}»`);
+    }
+    return {
+        blocking: textList(raw.blocking),
+        features: textOr(raw.features, 'features'),
+        groups: textList(raw.groups),
+        id: compileId(String(raw.id)),
+        pending: pendingOf(raw.pending),
+        removed: textOr(raw.removed, 'removed-scenarios.md'),
+    };
+};
+export const isProjectCovered = (config, project) => config.id.test(`${project}:AC-1-1.1`);

package/dist/esm/scenarios/coverage-data.d.ts

@@ -0,0 +1,53 @@
+import type { ClassifiedInterface } from './classes.js';
+import type { ScenariosInterface } from './classify.js';
+import type { FilesType } from './features.js';
+import type { ScenarioInterface } from './gherkin.js';
+import type { LinkRowInterface } from './task-links.js';
+export interface CoverageInterface {
+    readonly projects: readonly CoverageProjectInterface[];
+    readonly uncovered: readonly UncoveredStoryInterface[];
+}
+export interface CoverageProjectInterface {
+    readonly allRemoved: number;
+    readonly closed: number;
+    readonly codeTests: number;
+    readonly commit: string;
+    readonly covered: number;
+    readonly denominator: number;
+    readonly e2e: number;
+    readonly none: number;
+    readonly project: string;
+    readonly revision: string;
+    readonly share: number | undefined;
+    readonly unclassified: number;
+    readonly uncovered: Readonly<Record<UncoveredType, number>>;
+}
+export interface PendingInterface {
+    readonly file: string;
+    readonly id: string;
+    readonly line: number;
+    readonly stories: readonly ReferrerInterface[];
+    readonly title: string;
+    readonly url: string | undefined;
+}
+export interface UncoveredStoryInterface {
+    readonly file: string;
+    readonly project: string;
+    readonly scenarios: readonly string[];
+    readonly state: UncoveredType;
+    readonly story: string;
+    readonly url: string | undefined;
+}
+export type UncoveredType = (typeof uncoveredOrder)[number];
+interface ReferrerInterface {
+    readonly file: string;
+    readonly line: number;
+    readonly project: string;
+    readonly status: string;
+}
+export declare const uncoveredOrder: readonly ["off-run", "todo-only", "no-scenario"];
+export declare const uncoveredLabels: Readonly<Record<UncoveredType, string>>;
+export declare const liveScenarios: (ids: readonly string[], scenarios: ScenariosInterface) => ScenarioInterface[];
+export declare const coverageOf: (classified: readonly ClassifiedInterface[], scenarios: ScenariosInterface) => Promise<CoverageInterface>;
+export declare const pendingScenarios: (scenarios: ScenariosInterface, files: FilesType, rows: readonly LinkRowInterface[]) => Promise<PendingInterface[]>;
+export {};