@application-kit/acceptance 0.0.0-stage → 0.1.1

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

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

package/dist/esm/scenarios/declared.js

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

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

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

package/dist/esm/scenarios/features.js

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

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

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

package/dist/esm/scenarios/gherkin.js

@@ -0,0 +1,68 @@
+import { splitLines } from './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 splitLines(text).entries()) {
+        consumeLine(state, raw.trim(), index + 1);
+    }
+    return state;
+};
+export const parseFeature = (text, file) => parseState(text).scenarios
+    .map((scenario) => ({ file, ...scenario }));
+export const featureTags = (text) => parseState(text).featureTags;
+const languageLine = /^[\t ]*#[\t ]*language:[\t ]*(?<language>\S+)/mu;
+export const featureLanguage = (text) => languageLine.exec(text)?.groups?.language ?? 'en';
+export const where = (scenario) => `${scenario.file}:${scenario.line} «${scenario.title}»`;

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

@@ -0,0 +1,72 @@
+import { spawn } from 'node:child_process';
+import { realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { ConfigError } from './config.js';
+import { universalNewlines } from './python-text.js';
+export const currentRepo = '.';
+const decoder = new TextDecoder('utf-8');
+const ignorePipeError = () => {
+};
+export const runGit = async (location, gitArguments, input = '') => new Promise((resolve) => {
+    const child = 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);
+});
+export const stdoutText = (result) => universalNewlines(result.stdout.toString('utf8'));
+export const git = async (cwd, repo, gitArguments) => {
+    const done = await runGit({ cwd, repo }, gitArguments);
+    return done.code === 0 ? stdoutText(done) : undefined;
+};
+const realPath = async (target) => {
+    try {
+        return await realpath(target);
+    }
+    catch {
+        return target;
+    }
+};
+export const commonDirectory = async (cwd, repo) => {
+    const out = await git(cwd, repo, ['rev-parse', '--git-common-dir']);
+    return out === undefined ? undefined : realPath(path.resolve(cwd, repo, out.trim()));
+};
+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 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;
+};
+export const readAtRevision = async (location, revision, files) => {
+    const done = await runGit(location, ['cat-file', '--batch'], files.map((file) => `${revision}:${file}\n`).join(''));
+    if (done.code !== 0) {
+        throw new ConfigError(`git cat-file в ${location.repo} на ${revision} не прошёл: ${done.stderr.trim()}`);
+    }
+    return parseBatch({ describe: `${location.repo} нет ${revision}`, files, out: done.stdout });
+};

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

@@ -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/esm/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/esm/scenarios/inventory.js

@@ -0,0 +1,48 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { acceptanceFields } from './acceptance-class.js';
+import { ConfigError } from './config.js';
+import { allScenarios, readText, worktreeFeatures } from './features.js';
+import { featureLanguage, featureTags } from './gherkin.js';
+import { messageOf } from './python-text.js';
+import { parseRemoved } from './removed-list.js';
+export const 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: acceptanceFields(await readText(cwd, file)), file };
+    }
+    catch (error) {
+        throw new ConfigError(`story ${file} не читается: ${messageOf(error)}`);
+    }
+};
+const filesJson = (files) => [...files]
+    .map(([file, text]) => ({ language: featureLanguage(text), path: file, tags: featureTags(text) }));
+export const inventoryCommand = async (cwd, config, options) => {
+    const files = await worktreeFeatures(cwd, config);
+    const scenarios = allScenarios(files);
+    const removed = await 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: 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 = path.resolve(cwd, options.out);
+    await mkdir(path.dirname(target), { recursive: true });
+    await 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}`,
+    };
+};

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

@@ -0,0 +1,95 @@
+import { isProjectCovered, markPending, markQuarantine, markTodo } from './config.js';
+import { allScenarios, countMark, scenarioIds, worktreeFeatures } from './features.js';
+import { where } from './gherkin.js';
+import { compareText } from './python-text.js';
+import { parseRemoved } from './removed-list.js';
+import { linkToken, readProjects } from './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(markTodo)) {
+        return { debt: link };
+    }
+    const isPendingClosed = link.isClosed && owner.tags.includes(markPending);
+    const defect = `закрытая story ссылается на сценарий «ждёт реализации» @${link.tag}: ${link.location} → ${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(linkToken)]
+    .filter((match) => isProjectCovered(config, String(match[1])))
+    .map((match) => linkOf(row, match));
+const summaryOf = (scenarios, counts) => {
+    const pending = countMark(scenarios, markPending);
+    const quarantine = countMark(scenarios, markQuarantine);
+    const todo = countMark(scenarios, markTodo);
+    const tested = `с тестом ${scenarios.length - todo}, из них @${markPending} ${pending}, @${markQuarantine} ${quarantine}`;
+    const links = `ссылок из закрытых story ${counts.closed}, из незакрытых ${counts.open}`;
+    return `прочитано: сценариев ${scenarios.length} (${tested}; долгов @${markTodo} ${todo}), снятых ${counts.removed}; ${links}`;
+};
+const debtLine = (id, owner, references) => `долг: @${id} — ${where(owner)}; ссылки: ${references.join(', ') || 'нет'}`;
+const debtLines = (known, outcomes) => [...known.ids]
+    .toSorted(([left], [right]) => compareText(left, right))
+    .flatMap(([id, owners]) => owners.slice(0, 1)
+    .filter((owner) => owner.tags.includes(markTodo))
+    .map((owner) => debtLine(id, owner, outcomes.flatMap(({ debt }) => (debt?.tag === id ? [debt.location] : [])))));
+const knownOf = async (config, input, ids) => {
+    const removed = await parseRemoved(input.cwd, config.removed);
+    return { ids, removed: removed.entries };
+};
+export const linksCommand = async (config, input) => {
+    const files = await worktreeFeatures(input.cwd, config);
+    const known = await knownOf(config, input, scenarioIds(config, files));
+    const read = await 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(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'),
+    };
+};

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