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

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

@@ -0,0 +1,142 @@
+"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 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 RENAME and invalid-regex handling', () => {
+    (0, node_test_1.test)('detects semantic remove/add entries for property rename-like change', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-rename-');
+        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: {
+                            first_name: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            firstName: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        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'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const removed = report.changes.find(change => change.type === 'model.property.removed' && change.path === '#/components/schemas/User/properties/first_name');
+        const added = report.changes.find(change => change.type === 'model.property.added' && change.path === '#/components/schemas/User/properties/firstName');
+        node_assert_1.default.ok(removed, 'Expected semantic removal entry for previous property');
+        node_assert_1.default.ok(added, 'Expected semantic addition entry for renamed property');
+        node_assert_1.default.strictEqual(removed?.severity, 'breaking');
+        node_assert_1.default.strictEqual(added?.severity, 'non-breaking');
+    });
+    (0, node_test_1.test)('invalid regex in config does not crash and valid rules still apply', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-invalidregex-');
+        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: [
+                    {
+                        pattern: '(', // invalid regex
+                        reason: 'invalid pattern',
+                    },
+                    {
+                        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'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const filteredTypeChange = report.changes.find(change => change.type === 'model.property.type.changed' && change.path === '#/components/schemas/User/properties/age');
+        node_assert_1.default.ok(!filteredTypeChange, 'Expected matching semantic change to be filtered by valid rule while invalid regex is ignored');
+        node_assert_1.default.strictEqual(report.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.summary.nonBreaking, 0);
+        node_assert_1.default.strictEqual(report.summary.informational, 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'patch');
+    });
+});

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=analyzeDiffTypeCoercion.test.d.ts.map

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeDiffTypeCoercion.test.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,137 @@
+"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 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', () => {
+    (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.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.summary.breaking > 0);
+    });
+    (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.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.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.summary.nonBreaking, 0);
+        node_assert_1.default.strictEqual(report.summary.informational, 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'patch');
+    });
+});

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