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

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/logLegacyReport.d.ts

@@ -0,0 +1,6 @@
+import { DiffReport } from './types';
+/**
+ * Пишет legacy summary в лог.
+ */
+export declare function logLegacyReport(report: DiffReport, reportPath: string): void;
+//# sourceMappingURL=logLegacyReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logLegacyReport.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/logLegacyReport.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CA0B5E"}

package/dist/cli/analyzeDiff/logLegacyReport.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logLegacyReport = logLegacyReport;
+const Consts_1 = require("../../common/Consts");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
+/**
+ * Пишет legacy summary в лог.
+ */
+function logLegacyReport(report, reportPath) {
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.SEPARATOR);
+    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.LEGACY_BASE(report.metadata.base));
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_TARGET(report.metadata.target));
+    if (report.stats.stabilityScore !== undefined) {
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_STABILITY_SCORE(report.stats.stabilityScore));
+    }
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_CHANGES(report.stats));
+    if (report.diff.breaking.length > 0) {
+        Consts_1.APP_LOGGER.error(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_BREAKING(report.diff.breaking.length));
+    }
+    if (report.diff.warnings.length > 0) {
+        Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_WARNINGS(report.diff.warnings.length));
+    }
+    const ignored = report.stats.ignored ?? 0;
+    if (ignored > 0) {
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_IGNORED(ignored));
+    }
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.REPORT_CREATED(reportPath));
+}

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

@@ -0,0 +1,89 @@
+import type { DiffEntry, JsonValue, MiracleEntry } from './types';
+type PropertyChange = {
+    schemaPath: string;
+    schemaName: string;
+    propertyName: string;
+    entry: DiffEntry;
+    payload: Record<string, unknown>;
+    typeSignature?: string;
+    description?: string;
+    scalarType?: string;
+};
+/**
+ * Нормализует строковое имя (удаляет спецсимволы, приводит к 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;
+/**
+ * Извлекает и тримит описание свойства, если оно присутствует.
+ * @param payload объект описания свойства
+ * @returns описание или undefined
+ */
+export declare const getDescription: (payload: Record<string, unknown>) => string | undefined;
+/**
+ * Пытается извлечь подробную информацию об изменении свойства схемы из записи diff.
+ * Возвращает null если запись не представляет изменение свойства.
+ * @param entry запись diff
+ * @returns объект PropertyChange или null
+ */
+export declare const extractPropertyChange: (entry: DiffEntry) => PropertyChange | null;
+/**
+ * Определяет, указывает ли путь записи на свойство в схеме (содержит 'properties').
+ * @param entry запись diff
+ * @returns true если путь относится к свойству схемы
+ */
+export declare const isSchemaPropertyPath: (entry: DiffEntry) => boolean;
+/**
+ * Оценивает, могут ли два изменения (удаление и добавление) являться кандидатами на совпадение (rename).
+ * Сравнивает путь схемы и, при наличии, сигнатуры типов.
+ * @param removed информация об удалённом свойстве
+ * @param added информация о добавленном свойстве
+ * @returns true если кандидаты совместимы
+ */
+export declare const isSimilarityCandidate: (removed: PropertyChange, added: PropertyChange) => boolean;
+/**
+ * Вычисляет бонус к 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;
+/**
+ * Собирает карту путей свойств → нормализованный скалярный тип из спецификации.
+ * @param spec спецификация OpenAPI
+ * @returns Map с json-path как ключом и скалярным типом как значением
+ */
+export declare const collectPropertyScalarTypes: (spec: JsonValue) => Map<string, string>;
+/**
+ * Формирует список эвристических находок (miracles): переименования и коэрцирования типов.
+ * Сравнивает удалённые/добавленные свойства и изменения типов, добавляет записи с confidence.
+ * @param entries все собранные записи diff
+ * @param oldSpec нормализованная старая спецификация
+ * @param newSpec нормализованная новая спецификация
+ * @returns массив MiracleEntry
+ */
+export declare const buildMiracles: (entries: DiffEntry[], oldSpec: JsonValue, newSpec: JsonValue) => MiracleEntry[];
+export {};
+//# 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":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAElE,KAAK,cAAc,GAAG;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;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;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,SAK1E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,SAAS,KAAG,cAAc,GAAG,IAyBzE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,SAAS,KAAG,OAGvD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,SAAS,cAAc,EAAE,OAAO,cAAc,KAAG,OAQtF,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;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GAAI,MAAM,SAAS,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CA6B9E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,EAAE,EAAE,SAAS,SAAS,EAAE,SAAS,SAAS,KAAG,YAAY,EAsGxG,CAAC"}

package/dist/cli/analyzeDiff/miracles.js

@@ -0,0 +1,325 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMiracles = exports.collectPropertyScalarTypes = exports.computeConfidence = exports.descriptionSimilarityBonus = exports.isSimilarityCandidate = exports.isSchemaPropertyPath = exports.extractPropertyChange = exports.getDescription = exports.normalizeScalarType = exports.getTypeSignature = exports.normalizeName = void 0;
+const camelcase_1 = __importDefault(require("camelcase"));
+const leven_1 = __importDefault(require("leven"));
+const jsonPath_1 = require("../../common/utils/jsonPath");
+/**
+ * Нормализует строковое имя (удаляет спецсимволы, приводит к camelCase и lower-case).
+ * @param value исходная строка
+ * @returns нормализованное имя
+ */
+const normalizeName = (value) => {
+    const clean = value.replace(/[^a-zA-Z0-9]+/g, ' ').trim();
+    if (!clean) {
+        return value.toLowerCase();
+    }
+    return (0, camelcase_1.default)(clean).toLowerCase();
+};
+exports.normalizeName = normalizeName;
+/**
+ * Получает сигнатуру типа из описания свойства схемы (учитывает $ref, type, oneOf/anyOf/allOf).
+ * @param payload объект описания свойства
+ * @returns строковая сигнатура типа или undefined
+ */
+const getTypeSignature = (payload) => {
+    if (typeof payload.$ref === 'string') {
+        return `ref:${payload.$ref}`;
+    }
+    if (typeof payload.type === 'string') {
+        return String(payload.type);
+    }
+    if (Array.isArray(payload.oneOf)) {
+        return 'oneOf';
+    }
+    if (Array.isArray(payload.anyOf)) {
+        return 'anyOf';
+    }
+    if (Array.isArray(payload.allOf)) {
+        return 'allOf';
+    }
+    return undefined;
+};
+exports.getTypeSignature = getTypeSignature;
+/**
+ * Приводит разные обозначения скалярных типов к общим (number/string/boolean).
+ * @param value строковая сигнатура типа
+ * @returns нормализованный скалярный тип или undefined
+ */
+const normalizeScalarType = (value) => {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (normalized === 'int' || normalized === 'integer')
+        return 'number';
+    if (normalized === 'float' || normalized === 'double')
+        return 'number';
+    if (normalized === 'string')
+        return 'string';
+    if (normalized === 'number')
+        return 'number';
+    if (normalized === 'boolean')
+        return 'boolean';
+    return undefined;
+};
+exports.normalizeScalarType = normalizeScalarType;
+/**
+ * Извлекает и тримит описание свойства, если оно присутствует.
+ * @param payload объект описания свойства
+ * @returns описание или undefined
+ */
+const getDescription = (payload) => {
+    if (typeof payload.description === 'string') {
+        return payload.description.trim();
+    }
+    return undefined;
+};
+exports.getDescription = getDescription;
+/**
+ * Пытается извлечь подробную информацию об изменении свойства схемы из записи diff.
+ * Возвращает null если запись не представляет изменение свойства.
+ * @param entry запись diff
+ * @returns объект PropertyChange или null
+ */
+const extractPropertyChange = (entry) => {
+    const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+    const propertiesIndex = segments.indexOf('properties');
+    if (propertiesIndex === -1 || propertiesIndex + 1 !== segments.length - 1) {
+        return null;
+    }
+    const schemaPath = segments.slice(0, propertiesIndex).join('.');
+    const schemaName = segments[propertiesIndex - 1] ?? '';
+    const propertyName = segments[propertiesIndex + 1];
+    if (!schemaName || !propertyName)
+        return null;
+    const payload = (entry.action === 'removed' ? entry.from : entry.to);
+    if (!payload || typeof payload !== 'object')
+        return null;
+    return {
+        schemaPath,
+        schemaName,
+        propertyName,
+        entry,
+        payload,
+        typeSignature: (0, exports.getTypeSignature)(payload),
+        description: (0, exports.getDescription)(payload),
+        scalarType: (0, exports.normalizeScalarType)((0, exports.getTypeSignature)(payload)),
+    };
+};
+exports.extractPropertyChange = extractPropertyChange;
+/**
+ * Определяет, указывает ли путь записи на свойство в схеме (содержит 'properties').
+ * @param entry запись diff
+ * @returns true если путь относится к свойству схемы
+ */
+const isSchemaPropertyPath = (entry) => {
+    const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+    return segments.includes('properties');
+};
+exports.isSchemaPropertyPath = isSchemaPropertyPath;
+/**
+ * Оценивает, могут ли два изменения (удаление и добавление) являться кандидатами на совпадение (rename).
+ * Сравнивает путь схемы и, при наличии, сигнатуры типов.
+ * @param removed информация об удалённом свойстве
+ * @param added информация о добавленном свойстве
+ * @returns true если кандидаты совместимы
+ */
+const isSimilarityCandidate = (removed, added) => {
+    if (removed.schemaPath !== added.schemaPath)
+        return false;
+    if (removed.typeSignature && added.typeSignature) {
+        return removed.typeSignature === added.typeSignature;
+    }
+    return true;
+};
+exports.isSimilarityCandidate = isSimilarityCandidate;
+/**
+ * Вычисляет бонус к confidence на основе схожести описаний свойств.
+ * @param removed описание для удалённого свойства
+ * @param added описание для добавленного свойства
+ * @returns числовой бонус (0..0.05)
+ */
+const descriptionSimilarityBonus = (removed, added) => {
+    if (!removed || !added)
+        return 0;
+    const a = (0, exports.normalizeName)(removed);
+    const b = (0, exports.normalizeName)(added);
+    if (!a || !b)
+        return 0;
+    const distance = (0, leven_1.default)(a, b);
+    const ratio = distance / Math.max(a.length, b.length);
+    return ratio <= 0.4 ? 0.05 : 0;
+};
+exports.descriptionSimilarityBonus = descriptionSimilarityBonus;
+/**
+ * Комбинирует факторы в итоговую confidence (0..1) для RENAME эвристики.
+ * @param nameRatio нормализованное расстояние имён
+ * @param sameType флаг совпадения сигнатур типов
+ * @param onlyCandidate флаг единственного кандидата
+ * @param descBonus бонус от схожести описаний
+ * @returns итоговое confidence
+ */
+const computeConfidence = (nameRatio, sameType, onlyCandidate, descBonus) => {
+    let confidence = 1 - nameRatio;
+    if (sameType)
+        confidence += 0.1;
+    if (onlyCandidate)
+        confidence += 0.05;
+    confidence += descBonus;
+    if (confidence > 1)
+        confidence = 1;
+    if (confidence < 0)
+        confidence = 0;
+    return Number(confidence.toFixed(3));
+};
+exports.computeConfidence = computeConfidence;
+/**
+ * Собирает карту путей свойств → нормализованный скалярный тип из спецификации.
+ * @param spec спецификация OpenAPI
+ * @returns Map с json-path как ключом и скалярным типом как значением
+ */
+const collectPropertyScalarTypes = (spec) => {
+    const result = new Map();
+    if (!spec || typeof spec !== 'object')
+        return result;
+    const record = spec;
+    const schemas = (record.components && typeof record.components === 'object' ? record.components.schemas : undefined) ?? record.definitions;
+    if (!schemas || typeof schemas !== 'object')
+        return result;
+    for (const [schemaName, schemaValue] of Object.entries(schemas)) {
+        if (!schemaValue || typeof schemaValue !== 'object')
+            continue;
+        const schema = schemaValue;
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object')
+            continue;
+        for (const [propertyName, propertyValue] of Object.entries(properties)) {
+            if (!propertyValue || typeof propertyValue !== 'object')
+                continue;
+            const property = propertyValue;
+            const typeSignature = (0, exports.getTypeSignature)(property);
+            const scalar = (0, exports.normalizeScalarType)(typeSignature);
+            if (!scalar)
+                continue;
+            const baseSegments = record.components ? ['components', 'schemas', schemaName] : ['definitions', schemaName];
+            const path = (0, jsonPath_1.toJsonPath)([...baseSegments, 'properties', propertyName]);
+            result.set(path, scalar);
+        }
+    }
+    return result;
+};
+exports.collectPropertyScalarTypes = collectPropertyScalarTypes;
+/**
+ * Формирует список эвристических находок (miracles): переименования и коэрцирования типов.
+ * Сравнивает удалённые/добавленные свойства и изменения типов, добавляет записи с confidence.
+ * @param entries все собранные записи diff
+ * @param oldSpec нормализованная старая спецификация
+ * @param newSpec нормализованная новая спецификация
+ * @returns массив MiracleEntry
+ */
+const buildMiracles = (entries, oldSpec, newSpec) => {
+    const removedProps = [];
+    const addedProps = [];
+    const changedTypeProps = [];
+    for (const entry of entries) {
+        if (!(0, exports.isSchemaPropertyPath)(entry))
+            continue;
+        if (entry.action === 'removed' || entry.action === 'added') {
+            const change = (0, exports.extractPropertyChange)(entry);
+            if (!change)
+                continue;
+            if (entry.action === 'removed') {
+                removedProps.push(change);
+            }
+            else {
+                addedProps.push(change);
+            }
+            continue;
+        }
+        if (entry.action === 'changed') {
+            const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+            if (segments[segments.length - 1] !== 'type')
+                continue;
+            const propertyPath = (0, jsonPath_1.toJsonPath)(segments.slice(0, -1));
+            const fromTypeRaw = typeof entry.from === 'string' ? entry.from : (0, exports.getTypeSignature)((entry.from ?? {}));
+            const toTypeRaw = typeof entry.to === 'string' ? entry.to : (0, exports.getTypeSignature)((entry.to ?? {}));
+            const fromType = (0, exports.normalizeScalarType)(fromTypeRaw);
+            const toType = (0, exports.normalizeScalarType)(toTypeRaw);
+            if (!fromType || !toType || fromType === toType)
+                continue;
+            changedTypeProps.push({
+                path: propertyPath,
+                fromType,
+                toType,
+            });
+        }
+    }
+    const miracles = [];
+    for (const removed of removedProps) {
+        const candidates = addedProps.filter(added => (0, exports.isSimilarityCandidate)(removed, added));
+        if (candidates.length === 0)
+            continue;
+        const removedName = (0, exports.normalizeName)(removed.propertyName);
+        if (!removedName)
+            continue;
+        let best = null;
+        for (const candidate of candidates) {
+            const addedName = (0, exports.normalizeName)(candidate.propertyName);
+            if (!addedName)
+                continue;
+            const distance = (0, leven_1.default)(removedName, addedName);
+            const ratio = distance / Math.max(removedName.length, addedName.length);
+            if (!best || ratio < best.ratio) {
+                best = { candidate, ratio };
+            }
+        }
+        if (!best)
+            continue;
+        if (best.ratio > 0.2)
+            continue;
+        const sameType = !!removed.typeSignature && !!best.candidate.typeSignature && removed.typeSignature === best.candidate.typeSignature;
+        const onlyCandidate = candidates.length === 1;
+        const descBonus = (0, exports.descriptionSimilarityBonus)(removed.description, best.candidate.description);
+        const confidence = (0, exports.computeConfidence)(best.ratio, sameType, onlyCandidate, descBonus);
+        miracles.push({
+            oldPath: removed.entry.path,
+            newPath: best.candidate.entry.path,
+            type: 'RENAME',
+            confidence,
+            status: 'auto-generated',
+        });
+    }
+    const typeCoercionPaths = new Set();
+    for (const change of changedTypeProps) {
+        typeCoercionPaths.add(change.path);
+        miracles.push({
+            oldPath: change.path,
+            newPath: change.path,
+            type: 'TYPE_COERCION',
+            confidence: 1,
+            status: 'auto-generated',
+        });
+    }
+    const oldTypes = (0, exports.collectPropertyScalarTypes)(oldSpec);
+    const newTypes = (0, exports.collectPropertyScalarTypes)(newSpec);
+    for (const [path, oldType] of oldTypes.entries()) {
+        const newType = newTypes.get(path);
+        if (!newType || newType === oldType)
+            continue;
+        if (typeCoercionPaths.has(path))
+            continue;
+        typeCoercionPaths.add(path);
+        miracles.push({
+            oldPath: path,
+            newPath: path,
+            type: 'TYPE_COERCION',
+            confidence: 1,
+            status: 'auto-generated',
+        });
+    }
+    return miracles;
+};
+exports.buildMiracles = buildMiracles;

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

@@ -0,0 +1,5 @@
+/**
+ * Reads plugin paths from openapi config for semantic diff hooks.
+ */
+export declare function resolvePluginPaths(openapiConfig?: string): string[];
+//# sourceMappingURL=pluginPaths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pluginPaths.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/pluginPaths.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE"}

package/dist/cli/analyzeDiff/pluginPaths.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginPaths = resolvePluginPaths;
+const convertArrayToObject_1 = require("../../common/utils/convertArrayToObject");
+const loadConfigIfExists_1 = require("../../common/utils/loadConfigIfExists");
+/**
+ * Reads plugin paths from openapi config for semantic diff hooks.
+ */
+function resolvePluginPaths(openapiConfig) {
+    const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfig);
+    const config = (0, convertArrayToObject_1.convertArrayToObject)(configData);
+    return Array.isArray(config.plugins) ? config.plugins.filter((item) => typeof item === 'string' && !!item.trim()) : [];
+}

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

@@ -0,0 +1,3 @@
+export { buildLegacyReport as buildReport } from './buildLegacyReport';
+export { writeLegacyReport as writeReportToFile } from './writeLegacyReport';
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/report.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,IAAI,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,iBAAiB,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/cli/analyzeDiff/report.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeReportToFile = exports.buildReport = void 0;
+var buildLegacyReport_1 = require("./buildLegacyReport");
+Object.defineProperty(exports, "buildReport", { enumerable: true, get: function () { return buildLegacyReport_1.buildLegacyReport; } });
+var writeLegacyReport_1 = require("./writeLegacyReport");
+Object.defineProperty(exports, "writeReportToFile", { enumerable: true, get: function () { return writeLegacyReport_1.writeLegacyReport; } });

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

@@ -0,0 +1,6 @@
+import { Context } from '../../core/Context';
+/**
+ * Creates lightweight context for OpenAPI parsing in semantic diff mode.
+ */
+export declare function createSemanticDiffContext(input: string): Context;
+//# sourceMappingURL=semanticDiffContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semanticDiffContext.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/semanticDiffContext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAK7C;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKhE"}

package/dist/cli/analyzeDiff/semanticDiffContext.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemanticDiffContext = createSemanticDiffContext;
+const pathHelpers_1 = require("../../common/utils/pathHelpers");
+const Context_1 = require("../../core/Context");
+const getOutputPaths_1 = require("../../core/utils/getOutputPaths");
+const SEMANTIC_DIFF_TMP_OUTPUT = './test/generated/.semantic-diff-tmp';
+/**
+ * Creates lightweight context for OpenAPI parsing in semantic diff mode.
+ */
+function createSemanticDiffContext(input) {
+    return new Context_1.Context({
+        input: (0, pathHelpers_1.resolveHelper)(process.cwd(), input),
+        output: (0, getOutputPaths_1.getOutputPaths)({ output: SEMANTIC_DIFF_TMP_OUTPUT }),
+    });
+}

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

@@ -0,0 +1,22 @@
+import type { JsonValue } from './types';
+/**
+ * Читает и парсит спецификацию из файла. Поддерживает JSON и YAML через SwaggerParser.
+ * @param specPath путь к файлу спецификации
+ * @returns распарсенная спецификация
+ */
+export declare const parseSpecFile: (specPath: string) => Promise<JsonValue>;
+/**
+ * Парсит содержимое спецификации, переданное как строка. При YAML создаёт временный файл для парсинга.
+ * @param content строковое содержимое спецификации
+ * @param sourcePath исходный путь/идентификатор (используется для расширения временного файла)
+ * @returns распарсенная спецификация
+ */
+export declare const parseSpecContent: (content: string, sourcePath: string) => Promise<JsonValue>;
+/**
+ * Извлекает содержимое файла спецификации из Git по ref и парсит его.
+ * @param ref git-реф (например, HEAD~1)
+ * @param specPath путь к спецификации в репозитории
+ * @returns распарсенная спецификация из git
+ */
+export declare const readSpecFromGit: (ref: string, specPath: string) => Promise<JsonValue>;
+//# sourceMappingURL=specParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"specParser.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/specParser.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,SAAS,CAgBvE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAU,SAAS,MAAM,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,SAAS,CAuB7F,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,SAAS,CAYtF,CAAC"}