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

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"}

package/dist/cli/analyzeDiff/specParser.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSpecFromGit = exports.parseSpecContent = exports.parseSpecFile = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Читает и парсит спецификацию из файла. Поддерживает JSON и YAML через SwaggerParser.
+ * @param specPath путь к файлу спецификации
+ * @returns распарсенная спецификация
+ */
+const parseSpecFile = async (specPath) => {
+    const content = fs_1.default.readFileSync(specPath, 'utf-8');
+    const trimmed = content.trim();
+    if (!trimmed) {
+        throw new Error(`Specification file is empty: ${specPath}`);
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return JSON.parse(trimmed);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const SwaggerParser = require('@apidevtools/swagger-parser');
+    const parser = new SwaggerParser();
+    return parser.parse(specPath);
+};
+exports.parseSpecFile = parseSpecFile;
+/**
+ * Парсит содержимое спецификации, переданное как строка. При YAML создаёт временный файл для парсинга.
+ * @param content строковое содержимое спецификации
+ * @param sourcePath исходный путь/идентификатор (используется для расширения временного файла)
+ * @returns распарсенная спецификация
+ */
+const parseSpecContent = async (content, sourcePath) => {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        throw new Error(`Specification content is empty: ${sourcePath}`);
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return JSON.parse(trimmed);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const SwaggerParser = require('@apidevtools/swagger-parser');
+    const parser = new SwaggerParser();
+    const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'openapi-diff-'));
+    const ext = path_1.default.extname(sourcePath) || '.yaml';
+    const tmpFile = path_1.default.join(tmpDir, `spec${ext}`);
+    try {
+        fs_1.default.writeFileSync(tmpFile, content, 'utf-8');
+        return await parser.parse(tmpFile);
+    }
+    finally {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    }
+};
+exports.parseSpecContent = parseSpecContent;
+/**
+ * Извлекает содержимое файла спецификации из Git по ref и парсит его.
+ * @param ref git-реф (например, HEAD~1)
+ * @param specPath путь к спецификации в репозитории
+ * @returns распарсенная спецификация из git
+ */
+const readSpecFromGit = async (ref, specPath) => {
+    const relativePath = path_1.default.isAbsolute(specPath) ? path_1.default.relative(process.cwd(), specPath) : specPath;
+    const normalizedPath = path_1.default.normalize(relativePath);
+    const gitCommand = `git show ${ref}:${normalizedPath}`;
+    let content;
+    try {
+        content = (0, child_process_1.execSync)(gitCommand, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        const hint = `Failed to read '${specPath}' from git ref '${ref}'. Ensure you run this command in a git repository and the path exists at the specified ref.`;
+        throw new Error(`${hint} (${String(err)})`);
+    }
+    return (0, exports.parseSpecContent)(content, `${ref}:${normalizedPath}`);
+};
+exports.readSpecFromGit = readSpecFromGit;

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

@@ -0,0 +1,61 @@
+export type JsonValue = unknown;
+export type DiffAction = 'added' | 'removed' | 'changed';
+export type DiffSeverity = 'breaking' | 'warning' | 'info';
+export interface DiffEntry {
+    action: DiffAction;
+    path: string;
+    from?: JsonValue;
+    to?: JsonValue;
+    severity: DiffSeverity;
+    note?: string;
+    type?: string;
+}
+export interface DiffStats {
+    totalChanges: number;
+    added: number;
+    removed: number;
+    changed: number;
+    ignored?: number;
+    stabilityScore?: number;
+}
+export interface DiffReport {
+    version: string;
+    timestamp: string;
+    metadata: {
+        base: string;
+        target: string;
+        baseHash?: string;
+        targetHash?: string;
+    };
+    stats: DiffStats;
+    diff: {
+        breaking: DiffEntry[];
+        warnings: DiffEntry[];
+        info: DiffEntry[];
+        all: DiffEntry[];
+    };
+    miracles: MiracleEntry[];
+}
+export type MiracleType = 'RENAME' | 'TYPE_COERCION';
+export type MiracleStatus = 'auto-generated' | 'confirmed';
+export interface MiracleEntry {
+    oldPath: string;
+    newPath: string;
+    type: MiracleType;
+    confidence: number;
+    status: MiracleStatus;
+}
+export type IgnoreRule = {
+    path?: string;
+    pattern?: string;
+    reason?: string;
+    until?: string;
+};
+export type AnalyzeDiffResult = {
+    success: boolean;
+    reportPath?: string;
+    skipped?: boolean;
+    ignored?: number;
+    error?: string;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC;AAEhC,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAEzD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE3D,MAAM,WAAW,SAAS;IACtB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE;QACF,QAAQ,EAAE,SAAS,EAAE,CAAC;QACtB,QAAQ,EAAE,SAAS,EAAE,CAAC;QACtB,IAAI,EAAE,SAAS,EAAE,CAAC;QAClB,GAAG,EAAE,SAAS,EAAE,CAAC;KACpB,CAAC;IACF,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC5B;AAED,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,eAAe,CAAC;AAErD,MAAM,MAAM,aAAa,GAAG,gBAAgB,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,YAAY;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,MAAM,UAAU,GAAG;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/cli/analyzeDiff/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,6 @@
+import { DiffReport } from './types';
+/**
+ * Сохраняет legacy report на диск и логирует summary.
+ */
+export declare function writeLegacyReport(report: DiffReport, reportPath?: string): void;
+//# sourceMappingURL=writeLegacyReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeLegacyReport.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/writeLegacyReport.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,GAAE,MAAyC,GAAG,IAAI,CASjH"}

package/dist/cli/analyzeDiff/writeLegacyReport.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLegacyReport = writeLegacyReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Consts_1 = require("../../common/Consts");
+const logLegacyReport_1 = require("./logLegacyReport");
+/**
+ * Сохраняет legacy report на диск и логирует summary.
+ */
+function writeLegacyReport(report, reportPath = Consts_1.DEFAULT_ANALYZE_DIFF_REPORT_PATH) {
+    const reportDir = path_1.default.dirname(reportPath);
+    if (reportDir && reportDir !== '.' && !fs_1.default.existsSync(reportDir)) {
+        fs_1.default.mkdirSync(reportDir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+    (0, logLegacyReport_1.logLegacyReport)(report, reportPath);
+}

package/dist/cli/checkAndUpdateConfig/checkConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkConfig.d.ts","sourceRoot":"","sources":["../../../src/cli/checkAndUpdateConfig/checkConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAUzC;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CtE"}
+{"version":3,"file":"checkConfig.d.ts","sourceRoot":"","sources":["../../../src/cli/checkAndUpdateConfig/checkConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAWzC;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAgDtE"}