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

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

@@ -0,0 +1,17 @@
+import { OptionValues } from 'commander';
+export type AnalyzeDiffResult = {
+    success: boolean;
+    skipped?: boolean;
+    reportPath?: string;
+    ignored?: number;
+    error?: string;
+};
+/**
+ * Maps analyze-diff result to a process exit code. Does not call `process.exit`.
+ */
+export declare function toAnalyzeDiffExitCode(result: AnalyzeDiffResult): number;
+/**
+ * Runs semantic diff analysis between two OpenAPI specs and writes JSON report.
+ */
+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;AAoBzC,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;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEvE;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAuFnF"}

package/dist/cli/analyzeDiff/analyzeDiff.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnalyzeDiffExitCode = toAnalyzeDiffExitCode;
+exports.analyzeDiff = analyzeDiff;
+const Consts_1 = require("../../common/Consts");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
+const validateZodOptions_1 = require("../../common/Validation/validateZodOptions");
+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 getOpenApiSpec_1 = require("../../core/utils/getOpenApiSpec");
+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");
+/**
+ * Maps analyze-diff result to a process exit code. Does not call `process.exit`.
+ */
+function toAnalyzeDiffExitCode(result) {
+    return result.success ? 0 : 1;
+}
+/**
+ * Runs semantic diff analysis between two OpenAPI specs and writes JSON report.
+ */
+async function analyzeDiff(options) {
+    const validationResult = (0, validateZodOptions_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));
+        const newContext = (0, semanticDiffContext_1.createSemanticDiffContext)(newSpecInput);
+        const newSpec = await (0, getOpenApiSpec_1.getOpenApiSpec)(newContext, newSpecInput);
+        const oldSpec = oldSpecInput
+            ? await (0, getOpenApiSpec_1.getOpenApiSpec)((0, semanticDiffContext_1.createSemanticDiffContext)(oldSpecInput), oldSpecInput)
+            : (await (0, specParser_1.readSpecFromGit)(gitRef, 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 report = {
+            ...reportAfterIgnore,
+            governance: (0, evaluateGovernanceRules_1.evaluateGovernanceRules)({
+                openApi: newSpec,
+                breakingChangesCount: reportAfterIgnore.summary.breaking,
+                allowBreaking: validatedOptions.allowBreaking ?? false,
+                governanceConfig: governancePolicy,
+            }),
+        };
+        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(report, reportPath));
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.RECOMMENDATION(report));
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.GOVERNANCE(report));
+        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 && report.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/buildLegacyReport.d.ts

@@ -0,0 +1,17 @@
+import type { DiffReport, IgnoreRule, JsonValue } from './types';
+type BuildLegacyReportParams = {
+    baseLabel: string;
+    targetLabel: string;
+    oldSpec: JsonValue;
+    newSpec: JsonValue;
+    ignoreRules: IgnoreRule[];
+};
+/**
+ * Собирает legacy diff-отчет по сравнению двух спецификаций.
+ */
+export declare function buildLegacyReport(params: BuildLegacyReportParams): {
+    report: DiffReport;
+    ignored: number;
+};
+export {};
+//# sourceMappingURL=buildLegacyReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildLegacyReport.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/buildLegacyReport.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAa,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE5E,KAAK,uBAAuB,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,CAAC;IACnB,OAAO,EAAE,SAAS,CAAC;IACnB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA6C1G"}

package/dist/cli/analyzeDiff/buildLegacyReport.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLegacyReport = buildLegacyReport;
+const crypto_1 = __importDefault(require("crypto"));
+const diffEngine_1 = require("./diffEngine");
+const ignoreRules_1 = require("./ignoreRules");
+const miracles_1 = require("./miracles");
+/**
+ * Собирает legacy diff-отчет по сравнению двух спецификаций.
+ */
+function buildLegacyReport(params) {
+    const { baseLabel, targetLabel, oldSpec, newSpec, ignoreRules } = params;
+    const normalizedOld = (0, diffEngine_1.normalizeForDiff)(oldSpec);
+    const normalizedNew = (0, diffEngine_1.normalizeForDiff)(newSpec);
+    const baseHash = crypto_1.default.createHash('sha256').update(JSON.stringify(normalizedOld)).digest('hex');
+    const targetHash = crypto_1.default.createHash('sha256').update(JSON.stringify(normalizedNew)).digest('hex');
+    const entries = (0, diffEngine_1.withDiffType)((0, diffEngine_1.collectDiffEntries)(normalizedOld, normalizedNew));
+    const { filtered, ignored } = (0, ignoreRules_1.applyIgnoreRules)(entries, ignoreRules);
+    const breakingCount = filtered.filter(entry => entry.severity === 'breaking').length;
+    const stabilityScore = filtered.length === 0 ? 100 : Math.round(((filtered.length - breakingCount) / filtered.length) * 100);
+    const stats = {
+        totalChanges: filtered.length,
+        added: filtered.filter(entry => entry.action === 'added').length,
+        removed: filtered.filter(entry => entry.action === 'removed').length,
+        changed: filtered.filter(entry => entry.action === 'changed').length,
+        ignored: ignored || undefined,
+        stabilityScore,
+    };
+    const breaking = filtered.filter(entry => entry.severity === 'breaking');
+    const warnings = filtered.filter(entry => entry.severity === 'warning');
+    const info = filtered.filter(entry => entry.severity === 'info');
+    const report = {
+        version: '1.0.0',
+        timestamp: new Date().toISOString(),
+        metadata: {
+            base: baseLabel,
+            target: targetLabel,
+            baseHash,
+            targetHash,
+        },
+        stats,
+        diff: {
+            breaking,
+            warnings,
+            info,
+            all: filtered,
+        },
+        miracles: (0, miracles_1.buildMiracles)(entries, normalizedOld, normalizedNew),
+    };
+    return { report, ignored };
+}

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

@@ -0,0 +1,6 @@
+import { SemanticDiffReport } from '../../core/semanticDiff/analyzeOpenApiDiff';
+/**
+ * Builds markdown summary for CI logs.
+ */
+export declare function formatCiMarkdownSummary(report: SemanticDiffReport, 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,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAEhF;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAc9F"}

package/dist/cli/analyzeDiff/ciSummary.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCiMarkdownSummary = formatCiMarkdownSummary;
+/**
+ * Builds markdown summary for CI logs.
+ */
+function formatCiMarkdownSummary(report, reportPath) {
+    const reasons = report.recommendation.reasons.map(reason => `- \`${reason}\``).join('\n');
+    return [
+        '### OpenAPI Semantic Diff',
+        `- Report: \`${reportPath}\``,
+        `- Schema Version: \`${report.schemaVersion}\``,
+        `- Recommendation: \`${report.recommendation.semver}\` (confidence: \`${report.recommendation.confidence}\`)`,
+        `- Reason: ${report.recommendation.reason}`,
+        '- Reason Codes:',
+        reasons,
+        `- Summary: breaking=\`${report.summary.breaking}\`, nonBreaking=\`${report.summary.nonBreaking}\`, informational=\`${report.summary.informational}\``,
+        `- Governance: errors=\`${report.governance.summary.errors}\`, warnings=\`${report.governance.summary.warnings}\`, info=\`${report.governance.summary.info}\``,
+    ].join('\n');
+}

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

@@ -0,0 +1,54 @@
+import { Diff } from 'deep-diff';
+import type { DiffAction, DiffEntry, JsonValue } from './types';
+/**
+ * Проверяет, содержит ли путь сегменты, указывающие на полиморфную схему (oneOf/anyOf).
+ * @param segments сегменты json-path
+ * @returns true если встречены полиморфные сегменты
+ */
+export declare const hasPolymorphicSegment: (segments: (string | number)[]) => boolean;
+/**
+ * Классифицирует серьёзность изменения по действию (added/removed/changed).
+ * @param action действие изменения
+ * @returns уровень серьёзности
+ */
+export declare const classifySeverity: (action: DiffAction) => "info" | "warning" | "breaking";
+/**
+ * Строит единичную запись отличия из набора сегментов пути и значений.
+ * Добавляет заметку при полиморфных изменениях.
+ * @param action действие изменения
+ * @param segments сегменты пути
+ * @param from предыдущее значение
+ * @param to новое значение
+ * @returns готовая запись DiffEntry
+ */
+export declare const buildDiffEntry: (action: DiffAction, segments: (string | number)[], from?: JsonValue, to?: JsonValue) => DiffEntry;
+/**
+ * Пытается классифицировать тип изменения по структуре json-path и самой записи.
+ * Возвращает семантические коды типа изменения (METHOD_REMOVED, PROPERTY_ADDED и т.д.).
+ * @param entry запись diff
+ * @returns код типа изменения или undefined
+ */
+export declare const classifyDiffType: (entry: DiffEntry) => string | undefined;
+/**
+ * Добавляет поле type к каждой записи diff, вычисленное через classifyDiffType, если отсутствует.
+ * @param entries массив записей diff
+ * @returns массив записей с полем type
+ */
+export declare const withDiffType: (entries: DiffEntry[]) => DiffEntry[];
+/**
+ * Преобразует единичный объект отличия из deep-diff в один или несколько DiffEntry.
+ * Обрабатывает массивные/индексные отличия (kind 'A') рекурсивно.
+ * @param difference объект отличия от deep-diff
+ * @returns массив DiffEntry
+ */
+export declare const diffToEntries: (difference: Diff<unknown, unknown>) => DiffEntry[];
+/**
+ * Собирает все записи отличий между двумя JSON-структурами: старой и новой.
+ * Выполняет глубокое сравнение и маппинг на DiffEntry.
+ * @param oldValue старая версия спецификации
+ * @param newValue новая версия спецификации
+ * @returns массив DiffEntry
+ */
+export declare const collectDiffEntries: (oldValue: JsonValue, newValue: JsonValue) => DiffEntry[];
+export declare const normalizeForDiff: (value: JsonValue) => JsonValue;
+//# sourceMappingURL=diffEngine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diffEngine.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/diffEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,WAAW,CAAC;AAMnD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,UAAU,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,KAAG,OAErE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,UAAU,oCAUlD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,UAAU,EAAE,UAAU,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,SAAS,EAAE,KAAK,SAAS,KAAG,SAoBpH,CAAC;AA0BF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,MAAM,GAAG,SAwC5D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,SAAS,EAAE,KAAG,SAAS,EAK5D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,YAAY,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,KAAG,SAAS,EA8B3E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,SAAS,EAAE,UAAU,SAAS,KAAG,SAAS,EAMtF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,SAGnD,CAAC"}

package/dist/cli/analyzeDiff/diffEngine.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeForDiff = exports.collectDiffEntries = exports.diffToEntries = exports.withDiffType = exports.classifyDiffType = exports.buildDiffEntry = exports.classifySeverity = exports.hasPolymorphicSegment = void 0;
+const deep_diff_1 = require("deep-diff");
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const jsonPath_1 = require("../../common/utils/jsonPath");
+const normalizeObject_1 = require("../../common/utils/normalizeObject");
+const miracles_1 = require("./miracles");
+/**
+ * Проверяет, содержит ли путь сегменты, указывающие на полиморфную схему (oneOf/anyOf).
+ * @param segments сегменты json-path
+ * @returns true если встречены полиморфные сегменты
+ */
+const hasPolymorphicSegment = (segments) => {
+    return segments.includes('oneOf') || segments.includes('anyOf');
+};
+exports.hasPolymorphicSegment = hasPolymorphicSegment;
+/**
+ * Классифицирует серьёзность изменения по действию (added/removed/changed).
+ * @param action действие изменения
+ * @returns уровень серьёзности
+ */
+const classifySeverity = (action) => {
+    if (action === 'removed') {
+        return 'breaking';
+    }
+    if (action === 'changed') {
+        return 'warning';
+    }
+    return 'info';
+};
+exports.classifySeverity = classifySeverity;
+/**
+ * Строит единичную запись отличия из набора сегментов пути и значений.
+ * Добавляет заметку при полиморфных изменениях.
+ * @param action действие изменения
+ * @param segments сегменты пути
+ * @param from предыдущее значение
+ * @param to новое значение
+ * @returns готовая запись DiffEntry
+ */
+const buildDiffEntry = (action, segments, from, to) => {
+    const path = (0, jsonPath_1.toJsonPath)(segments);
+    if ((0, exports.hasPolymorphicSegment)(segments)) {
+        return {
+            action: 'changed',
+            path,
+            from,
+            to,
+            severity: 'warning',
+            note: 'Manual review required: polymorphic schema change',
+            type: 'POLYMORPHIC_CHANGE',
+        };
+    }
+    return {
+        action,
+        path,
+        from,
+        to,
+        severity: (0, exports.classifySeverity)(action),
+    };
+};
+exports.buildDiffEntry = buildDiffEntry;
+/**
+ * Возвращает имя корневой схемы из сегментов пути, если путь указывает на components.schemas или definitions.
+ * @param segments сегменты json-path
+ * @returns имя схемы или null
+ */
+const getSchemaRootName = (segments) => {
+    const s = segments.map(String);
+    if (s[0] === 'components' && s[1] === 'schemas')
+        return s[2] ?? null;
+    if (s[0] === 'definitions')
+        return s[1] ?? null;
+    return null;
+};
+/**
+ * Извлекает имя свойства из сегментов пути (ищет 'properties' и следующий сегмент).
+ * @param segments сегменты json-path
+ * @returns имя свойства или null
+ */
+const getPropertyNameFromSegments = (segments) => {
+    const s = segments.map(String);
+    const propsIndex = s.indexOf('properties');
+    if (propsIndex === -1)
+        return null;
+    return s[propsIndex + 1] ?? null;
+};
+/**
+ * Пытается классифицировать тип изменения по структуре json-path и самой записи.
+ * Возвращает семантические коды типа изменения (METHOD_REMOVED, PROPERTY_ADDED и т.д.).
+ * @param entry запись diff
+ * @returns код типа изменения или undefined
+ */
+const classifyDiffType = (entry) => {
+    const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+    const s = segments.map(String);
+    if (s[0] === 'paths') {
+        const hasMethod = s.length >= 3;
+        const isMethodRoot = s.length === 3;
+        if (hasMethod && isMethodRoot) {
+            if (entry.action === 'removed')
+                return 'METHOD_REMOVED';
+            if (entry.action === 'added')
+                return 'METHOD_ADDED';
+            return 'METHOD_CHANGED';
+        }
+        return 'PATH_CHANGED';
+    }
+    const schemaName = getSchemaRootName(s);
+    if (schemaName) {
+        const isSchemaRoot = s.length <= 3;
+        if (isSchemaRoot) {
+            if (entry.action === 'removed')
+                return 'SCHEMA_REMOVED';
+            if (entry.action === 'added')
+                return 'SCHEMA_ADDED';
+            return 'SCHEMA_CHANGED';
+        }
+        const propertyName = getPropertyNameFromSegments(s);
+        if (propertyName) {
+            const fromType = (0, miracles_1.getTypeSignature)((entry.from ?? {}));
+            const toType = (0, miracles_1.getTypeSignature)((entry.to ?? {}));
+            if (entry.action === 'changed' && fromType && toType && fromType !== toType) {
+                return 'TYPE_CHANGED';
+            }
+            if (entry.action === 'removed')
+                return 'PROPERTY_REMOVED';
+            if (entry.action === 'added')
+                return 'PROPERTY_ADDED';
+            return 'PROPERTY_CHANGED';
+        }
+        return 'SCHEMA_CHANGED';
+    }
+    return undefined;
+};
+exports.classifyDiffType = classifyDiffType;
+/**
+ * Добавляет поле type к каждой записи diff, вычисленное через classifyDiffType, если отсутствует.
+ * @param entries массив записей diff
+ * @returns массив записей с полем type
+ */
+const withDiffType = (entries) => {
+    return entries.map(entry => ({
+        ...entry,
+        type: entry.type ?? (0, exports.classifyDiffType)(entry),
+    }));
+};
+exports.withDiffType = withDiffType;
+/**
+ * Преобразует единичный объект отличия из deep-diff в один или несколько DiffEntry.
+ * Обрабатывает массивные/индексные отличия (kind 'A') рекурсивно.
+ * @param difference объект отличия от deep-diff
+ * @returns массив DiffEntry
+ */
+const diffToEntries = (difference) => {
+    if (difference.kind === 'A') {
+        const segments = [...(difference.path ?? []), difference.index];
+        const item = difference.item;
+        if (item.kind === 'A') {
+            return (0, exports.diffToEntries)({ ...item, path: segments });
+        }
+        if (item.kind === 'N') {
+            return [(0, exports.buildDiffEntry)('added', segments, undefined, item.rhs)];
+        }
+        if (item.kind === 'D') {
+            return [(0, exports.buildDiffEntry)('removed', segments, item.lhs, undefined)];
+        }
+        if (item.kind === 'E') {
+            return [(0, exports.buildDiffEntry)('changed', segments, item.lhs, item.rhs)];
+        }
+        return [];
+    }
+    const segments = difference.path ?? [];
+    if (difference.kind === 'N') {
+        return [(0, exports.buildDiffEntry)('added', segments, undefined, difference.rhs)];
+    }
+    if (difference.kind === 'D') {
+        return [(0, exports.buildDiffEntry)('removed', segments, difference.lhs, undefined)];
+    }
+    if (difference.kind === 'E') {
+        return [(0, exports.buildDiffEntry)('changed', segments, difference.lhs, difference.rhs)];
+    }
+    return [];
+};
+exports.diffToEntries = diffToEntries;
+/**
+ * Собирает все записи отличий между двумя JSON-структурами: старой и новой.
+ * Выполняет глубокое сравнение и маппинг на DiffEntry.
+ * @param oldValue старая версия спецификации
+ * @param newValue новая версия спецификации
+ * @returns массив DiffEntry
+ */
+const collectDiffEntries = (oldValue, newValue) => {
+    if ((0, fast_deep_equal_1.default)(oldValue, newValue)) {
+        return [];
+    }
+    const differences = (0, deep_diff_1.diff)(oldValue, newValue) ?? [];
+    return differences.flatMap(exports.diffToEntries);
+};
+exports.collectDiffEntries = collectDiffEntries;
+const normalizeForDiff = (value) => {
+    // обёртка вокруг normalizeObject, если нужно
+    return (0, normalizeObject_1.normalizeObject)(value);
+};
+exports.normalizeForDiff = normalizeForDiff;

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

@@ -0,0 +1,33 @@
+import type { DiffEntry, IgnoreRule } from './types';
+/**
+ * Проверяет, активно ли правило игнорирования по полю `until`.
+ * @param rule правило игнорирования
+ * @returns true если правило активно или не содержит валидной даты
+ */
+export declare const isRuleActive: (rule: IgnoreRule) => boolean;
+/**
+ * Проверяет, соответствует ли запись diff правилу игнорирования.
+ * Совмещает полное совпадение пути, префикс и регулярные выражения.
+ * @param entry запись отличия
+ * @param rule правило игнорирования
+ * @returns true если правило применимо к записи
+ */
+export declare const matchesIgnoreRule: (entry: DiffEntry, rule: IgnoreRule) => boolean;
+/**
+ * Применяет набор правил игнорирования к массиву записей и возвращает отфильтрованные записи и число игнорированных.
+ * @param entries список записей diff
+ * @param rules список правил игнорирования
+ * @returns объект с полем filtered и числом ignored
+ */
+export declare const applyIgnoreRules: (entries: DiffEntry[], rules: IgnoreRule[]) => {
+    filtered: DiffEntry[];
+    ignored: number;
+};
+/**
+ * Извлекает правила игнорирования из загруженной конфигурации openapi.
+ * @param configData загруженные данные конфигурации
+ * @returns список правил ignore
+ */
+export declare const getIgnoreRulesFromConfig: (configData: Record<string, any> | Record<string, any>[] | null) => IgnoreRule[];
+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;AAErD;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,UAAU,KAAG,OAK/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,EAAE,MAAM,UAAU,KAAG,OAkBtE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,SAAS,EAAE,EAAE,OAAO,UAAU,EAAE,KAAG;IAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAapH,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACjC,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,KAC/D,UAAU,EAOZ,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oBAAoB,MAAM,KAAG,UAAU,EAGtE,CAAC"}

package/dist/cli/analyzeDiff/ignoreRules.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIgnoreRules = exports.getIgnoreRulesFromConfig = exports.applyIgnoreRules = exports.matchesIgnoreRule = exports.isRuleActive = 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;
+};
+exports.isRuleActive = isRuleActive;
+/**
+ * Проверяет, соответствует ли запись diff правилу игнорирования.
+ * Совмещает полное совпадение пути, префикс и регулярные выражения.
+ * @param entry запись отличия
+ * @param rule правило игнорирования
+ * @returns true если правило применимо к записи
+ */
+const matchesIgnoreRule = (entry, rule) => {
+    if (!(0, exports.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;
+/**
+ * Применяет набор правил игнорирования к массиву записей и возвращает отфильтрованные записи и число игнорированных.
+ * @param entries список записей diff
+ * @param rules список правил игнорирования
+ * @returns объект с полем filtered и числом ignored
+ */
+const applyIgnoreRules = (entries, rules) => {
+    if (!rules.length) {
+        return { filtered: entries, ignored: 0 };
+    }
+    let ignored = 0;
+    const filtered = entries.filter(entry => {
+        const shouldIgnore = rules.some(rule => (0, exports.matchesIgnoreRule)(entry, rule));
+        if (shouldIgnore)
+            ignored += 1;
+        return !shouldIgnore;
+    });
+    return { filtered, ignored };
+};
+exports.applyIgnoreRules = applyIgnoreRules;
+/**
+ * Извлекает правила игнорирования из загруженной конфигурации 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 ?? [];
+};
+exports.getIgnoreRulesFromConfig = getIgnoreRulesFromConfig;
+const loadIgnoreRules = (openapiConfigPath) => {
+    const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfigPath);
+    return (0, exports.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"}