ts-openapi-codegen 2.0.0 → 2.1.0-beta.10

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const silenceLoggers_1 = require("../../../test/helpers/silenceLoggers");
+const analyzeDiff_1 = require("../analyzeDiff");
+const writeSpec = (dir, filename, payload) => {
+    const filePath = node_path_1.default.join(dir, filename);
+    node_fs_1.default.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf-8');
+    return filePath;
+};
+const generatedRoot = node_path_1.default.join(__dirname, 'generated');
+const createTempDir = (t, prefix) => {
+    node_fs_1.default.mkdirSync(generatedRoot, { recursive: true });
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(generatedRoot, prefix));
+    t.after(() => {
+        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    });
+    return tempDir;
+};
+(0, node_test_1.describe)('@unit: analyzeDiff TYPE_COERCION miracles', () => {
+    let restoreAppLogger;
+    (0, node_test_1.beforeEach)(() => {
+        restoreAppLogger = (0, silenceLoggers_1.installSilenceAppLogger)();
+    });
+    (0, node_test_1.afterEach)(() => {
+        restoreAppLogger?.();
+        restoreAppLogger = undefined;
+    });
+    (0, node_test_1.test)('detects semantic type change for scalar property transition', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-test-');
+        const reportPath = node_path_1.default.join(tmpDir, 'report.json');
+        const previousSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        };
+        const previousPath = writeSpec(tmpDir, 'previous.json', previousSpec);
+        const currentPath = writeSpec(tmpDir, 'current.json', currentSpec);
+        const result = await (0, analyzeDiff_1.analyzeDiff)({
+            input: currentPath,
+            compareWith: previousPath,
+            outputReport: reportPath,
+        });
+        node_assert_1.default.ok(result.success, `analyzeDiff failed: ${result.error ?? 'unknown error'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const typeChange = report.semantic.changes.find(change => change.type === 'model.property.type.changed');
+        node_assert_1.default.ok(typeChange, 'Expected semantic type-change entry');
+        node_assert_1.default.strictEqual(typeChange?.path, '#/components/schemas/User/properties/age');
+        node_assert_1.default.strictEqual(typeChange?.severity, 'breaking');
+        node_assert_1.default.ok(report.semantic.summary.breaking > 0);
+        node_assert_1.default.ok(report.structural.miracles.some(miracle => miracle.type === 'TYPE_COERCION'));
+    });
+    (0, node_test_1.test)('filters semantic type-change entry when rule matches path', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-test-');
+        const reportPath = node_path_1.default.join(tmpDir, 'report.json');
+        const previousSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        };
+        const previousPath = writeSpec(tmpDir, 'previous.json', previousSpec);
+        const currentPath = writeSpec(tmpDir, 'current.json', currentSpec);
+        const configPath = node_path_1.default.join(tmpDir, 'openapi.config.json');
+        node_fs_1.default.writeFileSync(configPath, JSON.stringify({
+            analyze: {
+                ignore: [
+                    {
+                        path: '#/components/schemas/User/properties/age',
+                        reason: 'Ignore type diff in test',
+                    },
+                ],
+            },
+        }, null, 2), 'utf-8');
+        const result = await (0, analyzeDiff_1.analyzeDiff)({
+            input: currentPath,
+            compareWith: previousPath,
+            outputReport: reportPath,
+            openapiConfig: configPath,
+        });
+        node_assert_1.default.ok(result.success, `analyzeDiff failed: ${result.error ?? 'unknown error'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const filteredTypeChange = report.semantic.changes.find(change => change.type === 'model.property.type.changed' && change.path === '#/components/schemas/User/properties/age');
+        node_assert_1.default.ok(!filteredTypeChange, 'Expected semantic type-change to be filtered by analyze.ignore');
+        node_assert_1.default.strictEqual(report.semantic.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.semantic.summary.nonBreaking, 0);
+        node_assert_1.default.strictEqual(report.semantic.summary.informational, 0);
+        node_assert_1.default.strictEqual(report.semantic.recommendation.semver, 'patch');
+    });
+});

package/dist/cli/analyzeDiff/analyzeDiff.d.ts

@@ -0,0 +1,29 @@
+import { OptionValues } from 'commander';
+/**
+ * Результат выполнения команды analyze-diff.
+ * @property success признак успешного завершения
+ * @property [skipped] анализ пропущен из-за отсутствия базовой спецификации
+ * @property [reportPath] абсолютный путь к сохранённому отчёту
+ * @property [ignored] количество проигнорированных изменений
+ * @property [error] текст ошибки при неуспешном завершении
+ */
+export type AnalyzeDiffResult = {
+    success: boolean;
+    skipped?: boolean;
+    reportPath?: string;
+    ignored?: number;
+    error?: string;
+};
+/**
+ * Преобразует результат analyze-diff в код выхода процесса. Не вызывает `process.exit`.
+ * @param result результат выполнения analyze-diff
+ * @returns код выхода: 0 при успехе, 1 при ошибке
+ */
+export declare function toAnalyzeDiffExitCode(result: AnalyzeDiffResult): number;
+/**
+ * Выполняет семантическое сравнение двух OpenAPI-спецификаций и записывает JSON-отчёт.
+ * @param options опции CLI команды analyze-diff
+ * @returns результат выполнения с путём к отчёту или описанием ошибки
+ */
+export declare function analyzeDiff(options: OptionValues): Promise<AnalyzeDiffResult>;
+//# sourceMappingURL=analyzeDiff.d.ts.map

package/dist/cli/analyzeDiff/analyzeDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeDiff.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/analyzeDiff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAuBzC;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEvE;AAqBD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAuGnF"}

package/dist/cli/analyzeDiff/analyzeDiff.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnalyzeDiffExitCode = toAnalyzeDiffExitCode;
+exports.analyzeDiff = analyzeDiff;
+const crypto_1 = __importDefault(require("crypto"));
+const Consts_1 = require("../../common/Consts");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
+const Validation_1 = require("../../common/Validation");
+const evaluateGovernanceRules_1 = require("../../core/governance/evaluateGovernanceRules");
+const loadGovernanceConfig_1 = require("../../core/governance/loadGovernanceConfig");
+const applySemanticDiffPluginHooks_1 = require("../../core/plugins/applySemanticDiffPluginHooks");
+const loadGeneratorPlugins_1 = require("../../core/plugins/loadGeneratorPlugins");
+const analyzeOpenApiDiff_1 = require("../../core/semanticDiff/analyzeOpenApiDiff");
+const DiffReport_model_1 = require("../../core/types/DiffReport.model");
+const adapters_1 = require("../../core/utils/adapters");
+const buildMiraclesFromSemanticChanges_1 = require("../../core/utils/buildMiraclesFromSemanticChanges");
+const loadSemanticOpenApiSpec_1 = require("../../core/utils/loadSemanticOpenApiSpec");
+const schemas_1 = require("../schemas");
+const ciSummary_1 = require("./ciSummary");
+const ignoreRules_1 = require("./ignoreRules");
+const ignoreSemanticChanges_1 = require("./ignoreSemanticChanges");
+const pluginPaths_1 = require("./pluginPaths");
+const semanticDiffContext_1 = require("./semanticDiffContext");
+const specParser_1 = require("./specParser");
+/**
+ * Преобразует результат analyze-diff в код выхода процесса. Не вызывает `process.exit`.
+ * @param result результат выполнения analyze-diff
+ * @returns код выхода: 0 при успехе, 1 при ошибке
+ */
+function toAnalyzeDiffExitCode(result) {
+    return result.success ? 0 : 1;
+}
+function createSpecHash(spec) {
+    const seen = new WeakSet();
+    const serializedSpec = JSON.stringify(spec, (_key, value) => {
+        if (value && typeof value === 'object') {
+            if (seen.has(value)) {
+                return '[Circular]';
+            }
+            seen.add(value);
+        }
+        return value;
+    });
+    return crypto_1.default
+        .createHash('sha256')
+        .update(serializedSpec ?? '')
+        .digest('hex');
+}
+/**
+ * Выполняет семантическое сравнение двух OpenAPI-спецификаций и записывает JSON-отчёт.
+ * @param options опции CLI команды analyze-diff
+ * @returns результат выполнения с путём к отчёту или описанием ошибки
+ */
+async function analyzeDiff(options) {
+    const validationResult = (0, Validation_1.validateZodOptions)(schemas_1.analyzeDiffOptionsSchema, options);
+    if (!validationResult.success) {
+        const message = validationResult.errors.join('\n');
+        Consts_1.APP_LOGGER.error(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.VALIDATION_ERROR(message));
+        return { success: false, error: message };
+    }
+    try {
+        const validatedOptions = validationResult.data;
+        const reportPathInput = validatedOptions.outputReport ?? Consts_1.DEFAULT_ANALYZE_DIFF_REPORT_PATH;
+        const newSpecInput = validatedOptions.input;
+        const oldSpecInput = validatedOptions.compareWith;
+        const gitRef = validatedOptions.git;
+        if (!oldSpecInput && !gitRef) {
+            Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.SKIPPED_NO_BASE);
+            return { success: true, skipped: true };
+        }
+        const baseSourceLabel = oldSpecInput ? `compare-with:${oldSpecInput}` : `git:${gitRef}`;
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.STARTED(newSpecInput, baseSourceLabel));
+        (0, semanticDiffContext_1.createSemanticDiffContext)(newSpecInput);
+        const newSpec = await (0, loadSemanticOpenApiSpec_1.loadSemanticOpenApiSpec)(newSpecInput);
+        const oldSpec = oldSpecInput ? await (0, loadSemanticOpenApiSpec_1.loadSemanticOpenApiSpec)(oldSpecInput) : await (0, loadSemanticOpenApiSpec_1.loadSemanticOpenApiObject)(await (0, specParser_1.readSpecFromGit)(gitRef, newSpecInput), newSpecInput);
+        if (oldSpecInput && validatedOptions.git) {
+            Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.COMPARE_WITH_OVERRIDES_GIT(validatedOptions.git));
+        }
+        const governancePolicy = await (0, loadGovernanceConfig_1.loadGovernanceConfig)(validatedOptions.governanceConfig);
+        const ignoreRules = (0, ignoreRules_1.loadIgnoreRules)(validatedOptions.openapiConfig);
+        const plugins = await (0, loadGeneratorPlugins_1.loadGeneratorPlugins)((0, pluginPaths_1.resolvePluginPaths)(validatedOptions.openapiConfig));
+        const baseReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec, {
+            allowBreaking: validatedOptions.allowBreaking ?? false,
+            governanceConfig: governancePolicy,
+        });
+        const pluginHooksResult = await (0, applySemanticDiffPluginHooks_1.applySemanticDiffPluginHooks)({
+            report: baseReport,
+            reportPath: reportPathInput,
+            plugins,
+            allowBreaking: validatedOptions.allowBreaking ?? false,
+            strictPluginMode: validatedOptions.strictPluginMode ?? false,
+            onDiagnostic: diagnostic => {
+                Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.PLUGIN_DIAGNOSTIC(diagnostic));
+            },
+        });
+        const { report: reportAfterIgnore, ignored } = (0, ignoreSemanticChanges_1.filterSemanticChangesByIgnoreRules)(pluginHooksResult.report, ignoreRules);
+        const semanticReport = {
+            ...reportAfterIgnore,
+            governance: (0, evaluateGovernanceRules_1.evaluateGovernanceRules)({
+                openApi: newSpec,
+                breakingChangesCount: reportAfterIgnore.summary.breaking,
+                allowBreaking: validatedOptions.allowBreaking ?? false,
+                governanceConfig: governancePolicy,
+            }),
+            miracles: (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(reportAfterIgnore.changes),
+        };
+        const report = {
+            schemaVersion: DiffReport_model_1.UNIFIED_DIFF_REPORT_SCHEMA_VERSION,
+            timestamp: new Date().toISOString(),
+            metadata: {
+                base: baseSourceLabel,
+                target: newSpecInput,
+                baseHash: createSpecHash(oldSpec),
+                targetHash: createSpecHash(newSpec),
+            },
+            semantic: {
+                changes: semanticReport.changes,
+                governance: semanticReport.governance,
+                recommendation: semanticReport.recommendation,
+                summary: semanticReport.summary,
+            },
+            structural: (0, adapters_1.adaptSemanticToStructural)(semanticReport, ignored),
+        };
+        const reportPath = await (0, analyzeOpenApiDiff_1.writeSemanticDiffReport)(report, pluginHooksResult.reportPath);
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.REPORT_CREATED(reportPath));
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.SUMMARY(semanticReport, reportPath));
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.RECOMMENDATION(semanticReport));
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.GOVERNANCE(semanticReport));
+        if (ignored > 0) {
+            Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.IGNORED_CHANGES(ignored));
+        }
+        if (validatedOptions.ci) {
+            Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.CI_MARKDOWN_SUMMARY((0, ciSummary_1.formatCiMarkdownSummary)(report, reportPath)));
+        }
+        if (validatedOptions.ci && semanticReport.governance.summary.errors > 0) {
+            return { success: false, reportPath, error: LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.CI_FAILURE };
+        }
+        return { success: true, reportPath, ignored };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Consts_1.APP_LOGGER.error(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.EXECUTION_ERROR(message));
+        return { success: false, error: message };
+    }
+}

package/dist/cli/analyzeDiff/ciSummary.d.ts

@@ -0,0 +1,9 @@
+import type { UnifiedDiffReport } from '../../core/types/DiffReport.model';
+/**
+ * Формирует markdown-сводку семантического diff для CI-логов.
+ * @param report унифицированный diff-отчёт
+ * @param reportPath путь к сохранённому отчёту
+ * @returns markdown-текст для вывода в CI
+ */
+export declare function formatCiMarkdownSummary(report: UnifiedDiffReport, reportPath: string): string;
+//# sourceMappingURL=ciSummary.d.ts.map

package/dist/cli/analyzeDiff/ciSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ciSummary.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ciSummary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAe7F"}

package/dist/cli/analyzeDiff/ciSummary.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCiMarkdownSummary = formatCiMarkdownSummary;
+/**
+ * Формирует markdown-сводку семантического diff для CI-логов.
+ * @param report унифицированный diff-отчёт
+ * @param reportPath путь к сохранённому отчёту
+ * @returns markdown-текст для вывода в CI
+ */
+function formatCiMarkdownSummary(report, reportPath) {
+    const semantic = report.semantic;
+    const reasons = semantic.recommendation.reasons.map(reason => `- \`${reason}\``).join('\n');
+    return [
+        '### OpenAPI Semantic Diff',
+        `- Report: \`${reportPath}\``,
+        `- Schema Version: \`${report.schemaVersion}\``,
+        `- Recommendation: \`${semantic.recommendation.semver}\` (confidence: \`${semantic.recommendation.confidence}\`)`,
+        `- Reason: ${semantic.recommendation.reason}`,
+        '- Reason Codes:',
+        reasons,
+        `- Summary: breaking=\`${semantic.summary.breaking}\`, nonBreaking=\`${semantic.summary.nonBreaking}\`, informational=\`${semantic.summary.informational}\``,
+        `- Governance: errors=\`${semantic.governance.summary.errors}\`, warnings=\`${semantic.governance.summary.warnings}\`, info=\`${semantic.governance.summary.info}\``,
+    ].join('\n');
+}

package/dist/cli/analyzeDiff/ignoreRules.d.ts

@@ -0,0 +1,11 @@
+import type { DiffEntry, IgnoreRule } from './types';
+/**
+ * Проверяет, соответствует ли запись diff правилу игнорирования.
+ * Совмещает полное совпадение пути, префикс и регулярные выражения.
+ * @param entry запись отличия
+ * @param rule правило игнорирования
+ * @returns true если правило применимо к записи
+ */
+export declare const matchesIgnoreRule: (entry: DiffEntry, rule: IgnoreRule) => boolean;
+export declare const loadIgnoreRules: (openapiConfigPath?: string) => IgnoreRule[];
+//# sourceMappingURL=ignoreRules.d.ts.map

package/dist/cli/analyzeDiff/ignoreRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignoreRules.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ignoreRules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAcrD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,EAAE,MAAM,UAAU,KAAG,OAkBtE,CAAC;AAgBF,eAAO,MAAM,eAAe,GAAI,oBAAoB,MAAM,KAAG,UAAU,EAGtE,CAAC"}

package/dist/cli/analyzeDiff/ignoreRules.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIgnoreRules = exports.matchesIgnoreRule = void 0;
+const Consts_1 = require("../../common/Consts");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
+const loadConfigIfExists_1 = require("../../common/utils/loadConfigIfExists");
+/**
+ * Проверяет, активно ли правило игнорирования по полю `until`.
+ * @param rule правило игнорирования
+ * @returns true если правило активно или не содержит валидной даты
+ */
+const isRuleActive = (rule) => {
+    if (!rule.until)
+        return true;
+    const timestamp = Date.parse(rule.until);
+    if (Number.isNaN(timestamp))
+        return true;
+    return Date.now() <= timestamp;
+};
+/**
+ * Проверяет, соответствует ли запись diff правилу игнорирования.
+ * Совмещает полное совпадение пути, префикс и регулярные выражения.
+ * @param entry запись отличия
+ * @param rule правило игнорирования
+ * @returns true если правило применимо к записи
+ */
+const matchesIgnoreRule = (entry, rule) => {
+    if (!isRuleActive(rule))
+        return false;
+    if (rule.path) {
+        if (entry.path === rule.path)
+            return true;
+        if (entry.path.startsWith(`${rule.path}.`))
+            return true;
+        if (entry.path.startsWith(`${rule.path}[`))
+            return true;
+        if (entry.path.startsWith(`${rule.path}/`))
+            return true;
+    }
+    if (rule.pattern) {
+        try {
+            const regex = new RegExp(rule.pattern);
+            return regex.test(entry.path);
+        }
+        catch (err) {
+            Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.INVALID_IGNORE_PATTERN(rule.pattern, String(err)));
+            return false;
+        }
+    }
+    return false;
+};
+exports.matchesIgnoreRule = matchesIgnoreRule;
+/**
+ * Извлекает правила игнорирования из загруженной конфигурации openapi.
+ * @param configData загруженные данные конфигурации
+ * @returns список правил ignore
+ */
+const getIgnoreRulesFromConfig = (configData) => {
+    if (!configData)
+        return [];
+    if (Array.isArray(configData)) {
+        const withAnalyze = configData.find(item => item?.analyze?.ignore);
+        return withAnalyze?.analyze?.ignore ?? [];
+    }
+    return configData.analyze?.ignore ?? [];
+};
+const loadIgnoreRules = (openapiConfigPath) => {
+    const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfigPath);
+    return getIgnoreRulesFromConfig(configData);
+};
+exports.loadIgnoreRules = loadIgnoreRules;

package/dist/cli/analyzeDiff/ignoreSemanticChanges.d.ts

@@ -0,0 +1,10 @@
+import { SemanticDiffReport } from '../../core/semanticDiff/analyzeOpenApiDiff';
+import { IgnoreRule } from './types';
+/**
+ * Applies legacy analyze.ignore rules to semantic changes and returns ignored count.
+ */
+export declare function filterSemanticChangesByIgnoreRules(report: SemanticDiffReport, ignoreRules: IgnoreRule[]): {
+    report: SemanticDiffReport;
+    ignored: number;
+};
+//# sourceMappingURL=ignoreSemanticChanges.d.ts.map

package/dist/cli/analyzeDiff/ignoreSemanticChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignoreSemanticChanges.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ignoreSemanticChanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAEhF,OAAO,EAAa,UAAU,EAAE,MAAM,SAAS,CAAC;AAqDhD;;GAEG;AACH,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,kBAAkB,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAmCzJ"}

package/dist/cli/analyzeDiff/ignoreSemanticChanges.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterSemanticChangesByIgnoreRules = filterSemanticChangesByIgnoreRules;
+const ignoreRules_1 = require("./ignoreRules");
+/**
+ * Rebuilds summary counters from current semantic changes.
+ */
+function rebuildSummary(report) {
+    return report.changes.reduce((acc, change) => {
+        if (change.severity === 'breaking') {
+            acc.breaking += 1;
+        }
+        else if (change.severity === 'non-breaking') {
+            acc.nonBreaking += 1;
+        }
+        else {
+            acc.informational += 1;
+        }
+        return acc;
+    }, { breaking: 0, nonBreaking: 0, informational: 0 });
+}
+/**
+ * Rebuilds recommendation based on recalculated summary.
+ */
+function rebuildRecommendation(summary) {
+    let semver = 'patch';
+    let confidence = 'high';
+    let reason = 'No breaking or feature-level changes detected.';
+    let reasons = ['NO_API_SURFACE_CHANGES'];
+    if (summary.breaking > 0) {
+        semver = 'major';
+        confidence = summary.breaking >= 3 ? 'high' : 'medium';
+        reason = 'Breaking changes detected.';
+        reasons = ['HAS_BREAKING_CHANGES'];
+    }
+    else if (summary.nonBreaking > 0) {
+        semver = 'minor';
+        confidence = summary.nonBreaking >= 3 ? 'high' : 'medium';
+        reason = 'Backward-compatible feature changes detected.';
+        reasons = ['HAS_BACKWARD_COMPATIBLE_CHANGES'];
+    }
+    else if (summary.informational > 0) {
+        semver = 'patch';
+        confidence = 'medium';
+        reason = 'Only informational changes detected.';
+        reasons = ['HAS_INFORMATIONAL_ONLY_CHANGES'];
+    }
+    return { semver, confidence, reason, reasons };
+}
+/**
+ * Applies legacy analyze.ignore rules to semantic changes and returns ignored count.
+ */
+function filterSemanticChangesByIgnoreRules(report, ignoreRules) {
+    if (!ignoreRules.length) {
+        return { report, ignored: 0 };
+    }
+    let ignored = 0;
+    const filteredChanges = report.changes.filter(change => {
+        const diffEntry = {
+            action: 'changed',
+            path: change.path,
+            severity: 'info',
+        };
+        const ignoredByRule = ignoreRules.some(rule => (0, ignoreRules_1.matchesIgnoreRule)(diffEntry, rule));
+        if (ignoredByRule) {
+            ignored += 1;
+            return false;
+        }
+        return true;
+    });
+    if (ignored === 0) {
+        return { report, ignored: 0 };
+    }
+    const summary = rebuildSummary({ ...report, changes: filteredChanges });
+    return {
+        report: {
+            ...report,
+            changes: filteredChanges,
+            summary,
+            recommendation: rebuildRecommendation(summary),
+        },
+        ignored,
+    };
+}

package/dist/cli/analyzeDiff/miracles.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Нормализует строковое имя (удаляет спецсимволы, приводит к camelCase и lower-case).
+ * @param value исходная строка
+ * @returns нормализованное имя
+ */
+export declare const normalizeName: (value: string) => string;
+/**
+ * Получает сигнатуру типа из описания свойства схемы (учитывает $ref, type, oneOf/anyOf/allOf).
+ * @param payload объект описания свойства
+ * @returns строковая сигнатура типа или undefined
+ */
+export declare const getTypeSignature: (payload: Record<string, unknown>) => string | undefined;
+/**
+ * Приводит разные обозначения скалярных типов к общим (number/string/boolean).
+ * @param value строковая сигнатура типа
+ * @returns нормализованный скалярный тип или undefined
+ */
+export declare const normalizeScalarType: (value?: string) => string | undefined;
+/**
+ * Вычисляет бонус к confidence на основе схожести описаний свойств.
+ * @param removed описание для удалённого свойства
+ * @param added описание для добавленного свойства
+ * @returns числовой бонус (0..0.05)
+ */
+export declare const descriptionSimilarityBonus: (removed?: string, added?: string) => number;
+/**
+ * Комбинирует факторы в итоговую confidence (0..1) для RENAME эвристики.
+ * @param nameRatio нормализованное расстояние имён
+ * @param sameType флаг совпадения сигнатур типов
+ * @param onlyCandidate флаг единственного кандидата
+ * @param descBonus бонус от схожести описаний
+ * @returns итоговое confidence
+ */
+export declare const computeConfidence: (nameRatio: number, sameType: boolean, onlyCandidate: boolean, descBonus: number) => number;
+//# sourceMappingURL=miracles.d.ts.map

package/dist/cli/analyzeDiff/miracles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"miracles.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/miracles.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,MAM7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,SAiB5E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,KAAG,MAAM,GAAG,SAS7D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,MAAM,EAAE,QAAQ,MAAM,KAAG,MAQ7E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,WAAW,MAAM,EAAE,UAAU,OAAO,EAAE,eAAe,OAAO,EAAE,WAAW,MAAM,KAAG,MAQnH,CAAC"}