@testmo/testmo-link 1.0.0-beta.0

package/dist/controller/automationLink.js

@@ -0,0 +1,636 @@
+"use strict";
+/*
+ * Copyright (c) Testmo GmbH (Berlin, Germany)
+ * All rights reserved.
+ * contact@testmo.com - www.testmo.com
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationLink = void 0;
+const controller_1 = require("../core/controller");
+const logger_1 = require("../lib/logger");
+const errors_1 = require("../lib/errors");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const validator_1 = __importDefault(require("validator"));
+// @ts-ignore
+const testmo = __importStar(require("@testmo/testmo-api"));
+// @ts-ignore
+const packageInfo = __importStar(require("../../package.json"));
+const retry_1 = require("../lib/retry");
+const annotationScanner_1 = require("../linking/annotationScanner");
+const patternMatcher_1 = require("../linking/patternMatcher");
+const DEFAULT_PRECEDENCE = [
+    'annotation',
+    'config',
+    'pattern',
+];
+class AutomationLink extends controller_1.Controller {
+    validate(options) {
+        if (!validator_1.default.isInt(options.projectId, { min: 1 })) {
+            throw new errors_1.ValidationError('Project ID needs to be a positive number');
+        }
+        if (!validator_1.default.isInt(options.runId, { min: 1 })) {
+            throw new errors_1.ValidationError('Run ID needs to be a positive number');
+        }
+        if (options.configFile !== undefined && !fs_1.default.existsSync(options.configFile)) {
+            throw new errors_1.ConfigError(`Config file not found: ${options.configFile}\n` +
+                `  Resolved path: ${path_1.default.resolve(options.configFile)}\n` +
+                `  Working directory: ${process.cwd()}`, options.configFile);
+        }
+        if (options.conflictResolution !== undefined &&
+            !['error', 'warn', 'silent'].includes(options.conflictResolution)) {
+            throw new errors_1.ValidationError('conflict-resolution must be one of: error, warn, silent');
+        }
+        this.validateProxy(options.proxy);
+    }
+    loadConfig(configFile) {
+        var _a;
+        if (!configFile) {
+            return {};
+        }
+        // T111 — warn on large config files; T110 — inform about memory implications > 10MB
+        try {
+            const stat = fs_1.default.statSync(configFile);
+            const sizeKB = Math.round(stat.size / 1024);
+            if (stat.size > 10 * 1024 * 1024) {
+                logger_1.logger.warn(`Config file is very large (${sizeKB}KB, >10MB). ` +
+                    `High memory usage expected. Consider using annotations or pattern matching instead.`);
+            }
+            else if (stat.size > 1024 * 1024) {
+                logger_1.logger.warn(`Config file is large (${sizeKB}KB, >1MB). ` +
+                    `For this many mappings, consider using annotations or pattern matching instead.`);
+            }
+        }
+        catch (_b) {
+            // Let readFileSync below report the real I/O error
+        }
+        let content;
+        try {
+            content = fs_1.default.readFileSync(configFile, 'utf8');
+        }
+        catch (e) {
+            throw new errors_1.ConfigError(`Cannot read config file: ${e.message}`, configFile);
+        }
+        const ext = path_1.default.extname(configFile).toLowerCase();
+        if (ext === '.json') {
+            try {
+                return JSON.parse(content);
+            }
+            catch (e) {
+                throw new errors_1.ConfigError(`Config file contains invalid JSON: ${e.message}\n` +
+                    `  File: ${path_1.default.resolve(configFile)}`, configFile);
+            }
+        }
+        // YAML (.yml or .yaml)
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const yaml = require('js-yaml');
+        try {
+            return ((_a = yaml.load(content)) !== null && _a !== void 0 ? _a : {});
+        }
+        catch (e) {
+            throw new errors_1.ConfigError(`Config file contains invalid YAML: ${e.message}\n` +
+                `  File: ${path_1.default.resolve(configFile)}`, configFile);
+        }
+    }
+    buildConfigLookup(config) {
+        var _a;
+        const lookup = new Map();
+        if (config.config_mappings) {
+            for (const mapping of config.config_mappings) {
+                const existing = (_a = lookup.get(mapping.test_name)) !== null && _a !== void 0 ? _a : [];
+                existing.push(mapping);
+                lookup.set(mapping.test_name, existing);
+            }
+        }
+        return lookup;
+    }
+    resolveConfigMapping(lookup, test) {
+        const candidates = lookup.get(test.name);
+        if (!candidates || candidates.length === 0)
+            return undefined;
+        if (candidates.length === 1)
+            return candidates[0].case_id;
+        // Multiple candidates — try folder disambiguation first
+        let filtered = candidates;
+        if (test.folder !== null) {
+            // Test has a folder — prefer entries that match it
+            const byFolder = filtered.filter(c => c.folder === test.folder);
+            if (byFolder.length > 0) {
+                filtered = byFolder;
+            }
+            else {
+                // No folder match — fall back to unscoped (no folder) entries
+                const unscoped = filtered.filter(c => !c.folder);
+                if (unscoped.length > 0) {
+                    filtered = unscoped;
+                }
+                else {
+                    // All entries are folder-scoped and none match this test's folder
+                    return undefined;
+                }
+            }
+        }
+        else {
+            // Test has no folder — prefer entries that don't restrict by folder
+            const unscoped = filtered.filter(c => !c.folder);
+            if (unscoped.length > 0)
+                filtered = unscoped;
+        }
+        // Then try file disambiguation
+        if (filtered.length > 1 && test.file !== null) {
+            const normFile = test.file.replace(/\\/g, '/');
+            const byFile = filtered.filter(c => {
+                if (!c.file)
+                    return false;
+                const normC = c.file.replace(/\\/g, '/');
+                return normC === normFile
+                    || normFile.endsWith('/' + normC)
+                    || normC.endsWith('/' + normFile);
+            });
+            if (byFile.length > 0) {
+                filtered = byFile;
+            }
+            else {
+                // No file match — fall back to unscoped (no file) entries
+                const unscopedFile = filtered.filter(c => !c.file);
+                if (unscopedFile.length > 0) {
+                    filtered = unscopedFile;
+                }
+                else {
+                    // All remaining entries specify a file but none match
+                    return undefined;
+                }
+            }
+        }
+        if (filtered.length === 1)
+            return filtered[0].case_id;
+        // Still ambiguous — warn and skip
+        logger_1.logger.warn(`config_mappings ambiguous for "${test.name}": ` +
+            `${filtered.length} entries still match after applying folder/file disambiguation. ` +
+            `Add more specific "folder" or "file" values to distinguish them.`);
+        return undefined;
+    }
+    createRawClient(address, proxy, token) {
+        if (!token || validator_1.default.isEmpty(token)) {
+            throw new errors_1.ValidationError('Missing Testmo API token (TESTMO_TOKEN environment variable)');
+        }
+        const requestLogger = (loggingRequest) => {
+            logger_1.logger.debug(`Request: ${loggingRequest.method} ${loggingRequest.url}`);
+        };
+        const client = new testmo.ApiClientEx();
+        client.plugins.push(requestLogger);
+        client.basePath = address;
+        client.authentications.bearerAuth.accessToken = token;
+        client.defaultHeaders = {
+            'Accept': 'application/json',
+            'User-Agent': `Testmo Link/${packageInfo.version} (www.testmo.com)`,
+        };
+        if (proxy) {
+            client.proxy = proxy;
+        }
+        return client;
+    }
+    async getAllRunTests(client, runId) {
+        var _a;
+        const allTests = [];
+        let page = 1;
+        const perPage = 1000;
+        while (true) {
+            const result = await (0, retry_1.withRetry)(() => client.callApi('/api/v1/automation/runs/{run_id}/tests', 'GET', { run_id: runId }, { page, per_page: perPage }, {}, {}, null, ['bearerAuth'], ['application/json'], ['application/json'], Object, null));
+            const data = result.data;
+            const tests = (_a = data === null || data === void 0 ? void 0 : data.result) !== null && _a !== void 0 ? _a : [];
+            allTests.push(...tests);
+            if (!(data === null || data === void 0 ? void 0 : data.next_page)) {
+                break;
+            }
+            page = data.next_page;
+        }
+        return allTests;
+    }
+    async createLinkBulk(client, projectId, links) {
+        await (0, retry_1.withRetry)(() => client.callApi('/api/v1/projects/{project_id}/automation-links/bulk', 'POST', { project_id: projectId }, {}, {}, {}, {
+            links: links.map(l => ({
+                case_id: l.repositoryCaseId,
+                automation_case_id: l.automationCaseId,
+            })),
+        }, ['bearerAuth'], ['application/json'], ['application/json'], Object, null));
+    }
+    async run(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+        this.logControllerOptions(options);
+        options.testmoInstanceAddress = this.validateAndTruncateInstanceAddress(options.testmoInstanceAddress);
+        this.validate(options);
+        // --- Load config ---
+        const config = this.loadConfig(options.configFile);
+        // Warn on unrecognized top-level config keys (catches typos like "include", "output.verbose")
+        if (options.configFile) {
+            const knownKeys = new Set([
+                'config_mappings', 'annotations', 'pattern_matching', 'precedence', 'settings',
+            ]);
+            for (const key of Object.keys(config)) {
+                if (!knownKeys.has(key)) {
+                    logger_1.logger.warn(`Unknown config key "${key}" in ${options.configFile} — ` +
+                        `not recognized and will be ignored. ` +
+                        `Valid top-level keys: ${[...knownKeys].join(', ')}`);
+                }
+            }
+        }
+        // Apply config file settings (CLI flags take priority over config settings)
+        if (((_a = config.settings) === null || _a === void 0 ? void 0 : _a.verbose) && logger_1.logger.level > logger_1.LogLevel.Debug) {
+            logger_1.logger.level = logger_1.LogLevel.Debug;
+        }
+        if (((_b = config.settings) === null || _b === void 0 ? void 0 : _b.output_file) && !logger_1.logger.outputFile) {
+            logger_1.logger.outputFile = config.settings.output_file;
+        }
+        // CLI flags override config file settings
+        const conflictResolution = (_e = (_c = options.conflictResolution) !== null && _c !== void 0 ? _c : (_d = config.settings) === null || _d === void 0 ? void 0 : _d.conflict_resolution) !== null && _e !== void 0 ? _e : 'error';
+        const precedence = ((_f = config.precedence) === null || _f === void 0 ? void 0 : _f.length) ? config.precedence : DEFAULT_PRECEDENCE;
+        // --- Config mappings ---
+        const configLookup = this.buildConfigLookup(config);
+        const configMappingEnabled = precedence.includes('config') && configLookup.size > 0;
+        if (configMappingEnabled) {
+            const totalMappings = [...configLookup.values()].reduce((n, arr) => n + arr.length, 0);
+            logger_1.logger.info(`Loaded ${totalMappings} config mapping(s)`);
+        }
+        else if (!options.configFile) {
+            logger_1.logger.warn('No config file specified and no mappings loaded. ' +
+                'Use --config <file> to specify a YAML/JSON config with mappings.');
+        }
+        else if (configLookup.size === 0 &&
+            !((_g = config.annotations) === null || _g === void 0 ? void 0 : _g.enabled) &&
+            !((_h = config.pattern_matching) === null || _h === void 0 ? void 0 : _h.enabled)) {
+            logger_1.logger.warn('No config_mappings found in config file. No links will be created.');
+        }
+        // --- API client ---
+        const client = this.createRawClient(options.testmoInstanceAddress, options.proxy, options.testmoApiToken);
+        // T113 — phase performance timers (reported in debug/verbose mode)
+        const phaseMs = { scan: 0, caseLoad: 0, fetch: 0, match: 0, link: 0 };
+        // --- Annotation scanner setup ---
+        let annotationScanner;
+        if (((_j = config.annotations) === null || _j === void 0 ? void 0 : _j.enabled) === true &&
+            ((_l = (_k = config.annotations.paths) === null || _k === void 0 ? void 0 : _k.length) !== null && _l !== void 0 ? _l : 0) === 0) {
+            logger_1.logger.warn('Annotation scanning is enabled but no paths are configured — skipping annotation scan.\n' +
+                'Add a "paths" key to your annotations configuration to specify which files to scan.');
+        }
+        const annotationEnabled = precedence.includes('annotation') &&
+            ((_m = config.annotations) === null || _m === void 0 ? void 0 : _m.enabled) === true &&
+            ((_p = (_o = config.annotations.paths) === null || _o === void 0 ? void 0 : _o.length) !== null && _p !== void 0 ? _p : 0) > 0;
+        if (annotationEnabled) {
+            annotationScanner = new annotationScanner_1.AnnotationScanner(config.annotations);
+            logger_1.logger.info(`Scanning files for annotations...`);
+            const t0 = Date.now();
+            await annotationScanner.scan(config.annotations.paths);
+            phaseMs.scan = Date.now() - t0;
+        }
+        // --- Pattern matcher setup ---
+        let patternMatcher;
+        const patternEnabled = precedence.includes('pattern') &&
+            ((_q = config.pattern_matching) === null || _q === void 0 ? void 0 : _q.enabled) === true;
+        if (patternEnabled) {
+            const rules = (_r = config.pattern_matching.rules) !== null && _r !== void 0 ? _r : [];
+            patternMatcher = new patternMatcher_1.PatternMatcher(rules);
+            logger_1.logger.info(`Loading repository cases for pattern matching...`);
+            const projectId = parseInt(options.projectId, 10);
+            const t0 = Date.now();
+            await patternMatcher.loadCases(client, projectId);
+            phaseMs.caseLoad = Date.now() - t0;
+            logger_1.logger.info(`Loaded ${patternMatcher.getCaseCount()} case(s) for pattern matching`);
+        }
+        // --- Fetch run tests ---
+        logger_1.logger.info(`Fetching test results for run ${options.runId}...`);
+        const fetchStart = Date.now();
+        const tests = await this.getAllRunTests(client, parseInt(options.runId, 10));
+        phaseMs.fetch = Date.now() - fetchStart;
+        logger_1.logger.info(`Found ${tests.length} test result(s)`);
+        // Build a set of all case IDs already linked across the run so that
+        // pattern matching can filter them out before the ambiguity check.
+        const allLinkedCaseIds = new Set();
+        for (const t of tests) {
+            if (t.repository_case_id !== null)
+                allLinkedCaseIds.add(t.repository_case_id);
+            for (const id of ((_s = t.repository_case_ids) !== null && _s !== void 0 ? _s : []))
+                allLinkedCaseIds.add(id);
+        }
+        // --- Matching phase ---
+        let matched = 0;
+        let alreadyLinked = 0;
+        let unmatched = 0;
+        let errors = 0;
+        const methodCounts = {
+            annotation: 0,
+            config: 0,
+            pattern: 0,
+        };
+        const startTime = Date.now();
+        const matchStart = Date.now();
+        const projectId = parseInt(options.projectId, 10);
+        // T102 — error counts by category for aggregated reporting.
+        // The bulk endpoint returns 422 for validation failures (not per-case 404s),
+        // so only two categories are needed.
+        const errorCounts = { validation: 0, other: 0 };
+        const conflictRecords = [];
+        const pendingLinks = [];
+        for (const test of tests) {
+            // Skip if already linked (unless --force).
+            // When annotation scanning is enabled, defer the skip — the annotation path
+            // handles per-ID filtering via repository_case_ids, so a test with one existing
+            // link may still need additional IDs linked.
+            if (test.repository_case_id !== null && !options.force && !annotationEnabled) {
+                alreadyLinked++;
+                logger_1.logger.debug(`Skipping already-linked: "${test.name}" → case ${test.repository_case_id}`);
+                continue;
+            }
+            // Try each method in precedence order, collect all results for conflict detection
+            const candidates = [];
+            let multiCaseDone = false;
+            // Tracks whether the annotation single-ID was suppressed because it's already linked
+            // (used to count the test as alreadyLinked rather than unmatched at the end)
+            let filteredByExistingLink = false;
+            for (const method of precedence) {
+                let caseId;
+                if (method === 'annotation' && annotationScanner) {
+                    const ids = annotationScanner.findCaseIds(test.name, test.file, test.folder);
+                    if (ids.length > 1 && candidates.length === 0) {
+                        // Multiple case IDs and no higher-precedence method matched —
+                        // filter out already-linked IDs, then create pending links for the rest.
+                        const existingIds = new Set([
+                            ...((_t = test.repository_case_ids) !== null && _t !== void 0 ? _t : []),
+                            ...(test.repository_case_id !== null ? [test.repository_case_id] : []),
+                        ]);
+                        const idsToLink = options.force
+                            ? ids
+                            : ids.filter(id => !existingIds.has(id));
+                        if (idsToLink.length === 0) {
+                            // All annotation IDs are already linked
+                            alreadyLinked++;
+                            logger_1.logger.debug(`Skipping already-linked: "${test.name}" → all ${ids.length} annotation IDs already linked`);
+                            multiCaseDone = true;
+                            break;
+                        }
+                        if (options.dryRun) {
+                            for (const id of idsToLink) {
+                                logger_1.logger.info(`[DRY RUN] Would link: "${test.name}" ` +
+                                    `(automation_case_id=${test.automation_case_id}) → case ${id}` +
+                                    ` [annotation]`);
+                                matched++;
+                                methodCounts.annotation++;
+                            }
+                        }
+                        else {
+                            for (const id of idsToLink) {
+                                pendingLinks.push({ test, caseId: id, method: 'annotation' });
+                            }
+                        }
+                        multiCaseDone = true;
+                        break;
+                    }
+                    // Single or no match — fall through to normal conflict-detection flow
+                    caseId = ids[0];
+                    // If this single ID is already linked, skip it to avoid a redundant POST
+                    if (caseId !== undefined && !options.force) {
+                        const existingIds = new Set([
+                            ...((_u = test.repository_case_ids) !== null && _u !== void 0 ? _u : []),
+                            ...(test.repository_case_id !== null ? [test.repository_case_id] : []),
+                        ]);
+                        if (existingIds.has(caseId)) {
+                            filteredByExistingLink = true;
+                            caseId = undefined;
+                        }
+                    }
+                }
+                else if (method === 'config' && configMappingEnabled) {
+                    // Skip non-annotation methods for already-linked tests (unless --force).
+                    // The early-exit above is deferred when annotationEnabled, but that deferral
+                    // is only needed for the annotation path — config/pattern should still respect
+                    // the already-linked state.
+                    if (test.repository_case_id !== null && !options.force)
+                        continue;
+                    caseId = this.resolveConfigMapping(configLookup, test);
+                }
+                else if (method === 'pattern' && patternMatcher) {
+                    if (test.repository_case_id !== null && !options.force)
+                        continue;
+                    caseId = patternMatcher.match(test.name, allLinkedCaseIds);
+                }
+                if (caseId !== undefined) {
+                    candidates.push({ method, caseId });
+                }
+            }
+            if (multiCaseDone)
+                continue;
+            if (candidates.length === 0) {
+                // Count as alreadyLinked if: the annotation single-ID was filtered because it's
+                // already linked, or the test has an existing link and annotations found nothing
+                // new to add (annotationEnabled bypassed the early-exit above).
+                if (filteredByExistingLink ||
+                    (test.repository_case_id !== null && !options.force)) {
+                    alreadyLinked++;
+                    logger_1.logger.debug(`Skipping already-linked: "${test.name}"`);
+                }
+                else {
+                    unmatched++;
+                    // T098 — per-test hint at debug level; summary-level suggestions follow
+                    logger_1.logger.debug(`No match found for: "${test.name}"`);
+                }
+                continue;
+            }
+            // Check for conflicts (same test matched to different case IDs by different methods)
+            const uniqueCaseIds = new Set(candidates.map(c => c.caseId));
+            let resolvedCaseId;
+            let resolvedMethod;
+            if (uniqueCaseIds.size > 1) {
+                const detail = candidates
+                    .map(c => `${c.method}→case ${c.caseId}`)
+                    .join(', ');
+                if (conflictResolution === 'error') {
+                    errors++;
+                    logger_1.logger.error(`Conflict for "${test.name}": multiple methods returned different case IDs (${detail})`);
+                    conflictRecords.push({
+                        testName: test.name,
+                        candidates,
+                        resolvedCaseId: null,
+                        resolvedMethod: null,
+                    });
+                    continue;
+                }
+                else if (conflictResolution === 'warn') {
+                    logger_1.logger.warn(`Conflict for "${test.name}": using first match (${detail})`);
+                }
+                // Both warn and silent: use the first match (highest precedence)
+                resolvedCaseId = candidates[0].caseId;
+                resolvedMethod = candidates[0].method;
+                conflictRecords.push({
+                    testName: test.name,
+                    candidates,
+                    resolvedCaseId,
+                    resolvedMethod,
+                });
+            }
+            else {
+                // All candidates agree — use the first (highest precedence method)
+                resolvedCaseId = candidates[0].caseId;
+                resolvedMethod = candidates[0].method;
+            }
+            if (options.dryRun) {
+                logger_1.logger.info(`[DRY RUN] Would link: "${test.name}" ` +
+                    `(automation_case_id=${test.automation_case_id}) → case ${resolvedCaseId}` +
+                    ` [${resolvedMethod}]`);
+                matched++;
+                methodCounts[resolvedMethod]++;
+                continue;
+            }
+            pendingLinks.push({ test, caseId: resolvedCaseId, method: resolvedMethod });
+        }
+        phaseMs.match = Date.now() - matchStart;
+        // --- Bulk link creation phase (up to 500 links per request) ---
+        // Each batch is a single POST to the bulk endpoint, reducing N individual
+        // requests to ceil(N/500) requests and eliminating the burst that triggers
+        // rate limiting.
+        const linkStart = Date.now();
+        const BULK_BATCH_SIZE = 500;
+        for (let i = 0; i < pendingLinks.length; i += BULK_BATCH_SIZE) {
+            const batch = pendingLinks.slice(i, i + BULK_BATCH_SIZE);
+            try {
+                await this.createLinkBulk(client, projectId, batch.map(({ test, caseId }) => ({
+                    repositoryCaseId: caseId,
+                    automationCaseId: test.automation_case_id,
+                })));
+                for (const { test, caseId, method } of batch) {
+                    matched++;
+                    methodCounts[method]++;
+                    logger_1.logger.debug(`Linked: "${test.name}" ` +
+                        `(automation_case_id=${test.automation_case_id}) → case ${caseId}` +
+                        ` [${method}]`);
+                }
+            }
+            catch (e) {
+                errors += batch.length;
+                const status = (_w = (_v = e === null || e === void 0 ? void 0 : e.response) === null || _v === void 0 ? void 0 : _v.status) !== null && _w !== void 0 ? _w : e === null || e === void 0 ? void 0 : e.status;
+                const msg = (_0 = (_z = (_y = (_x = e === null || e === void 0 ? void 0 : e.response) === null || _x === void 0 ? void 0 : _x.body) === null || _y === void 0 ? void 0 : _y.message) !== null && _z !== void 0 ? _z : e === null || e === void 0 ? void 0 : e.message) !== null && _0 !== void 0 ? _0 : (e != null && typeof e === 'object' ? JSON.stringify(e) : String(e));
+                if (status === 422 && ((_2 = (_1 = e === null || e === void 0 ? void 0 : e.response) === null || _1 === void 0 ? void 0 : _1.body) === null || _2 === void 0 ? void 0 : _2.errors)) {
+                    errorCounts.validation += batch.length;
+                    const fields = Object.entries(e.response.body.errors)
+                        .map(([f, msgs]) => `${f}: ${msgs[0]}`)
+                        .join(', ');
+                    logger_1.logger.error(`Error linking batch of ${batch.length}: validation failed — ${fields}`);
+                }
+                else {
+                    errorCounts.other += batch.length;
+                    logger_1.logger.error(`Error linking batch of ${batch.length}: ${msg}`);
+                }
+            }
+        }
+        phaseMs.link = Date.now() - linkStart;
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        // T113 — performance metrics in debug mode
+        logger_1.logger.debug(`Performance: scan=${phaseMs.scan}ms, caseLoad=${phaseMs.caseLoad}ms, ` +
+            `fetch=${phaseMs.fetch}ms, match=${phaseMs.match}ms, link=${phaseMs.link}ms`);
+        // --- Summary ---
+        logger_1.logger.info('');
+        logger_1.logger.info(`Automation linking complete (${elapsed}s):`);
+        logger_1.logger.info(`  Matched/linked:  ${matched}`);
+        logger_1.logger.info(`  Already linked:  ${alreadyLinked} (skipped)`);
+        logger_1.logger.info(`  Unmatched:       ${unmatched}`);
+        if (errors > 0) {
+            logger_1.logger.info(`  Errors:          ${errors}`);
+            // T102 — aggregate error breakdown by category
+            if (errorCounts.validation > 0) {
+                logger_1.logger.info(`    Validation failures: ${errorCounts.validation}`);
+            }
+            if (errorCounts.other > 0) {
+                logger_1.logger.info(`    Network/API errors: ${errorCounts.other}`);
+            }
+        }
+        // Show method breakdown if more than one method was active
+        const activeMethods = Object.keys(methodCounts).filter(m => methodCounts[m] > 0);
+        if (activeMethods.length > 1) {
+            logger_1.logger.info(`  By method:`);
+            for (const m of activeMethods) {
+                logger_1.logger.info(`    ${m}: ${methodCounts[m]}`);
+            }
+        }
+        // Show conflict details if any conflicts occurred
+        if (conflictRecords.length > 0) {
+            logger_1.logger.info('');
+            logger_1.logger.info(`Conflict details (${conflictRecords.length}):`);
+            for (const conflict of conflictRecords) {
+                const candidateStr = conflict.candidates
+                    .map(c => `${c.method}→case ${c.caseId}`)
+                    .join(', ');
+                if (conflict.resolvedCaseId !== null) {
+                    logger_1.logger.info(`  "${conflict.testName}": ${candidateStr}` +
+                        ` → resolved: ${conflict.resolvedCaseId} [${conflict.resolvedMethod}]`);
+                }
+                else {
+                    logger_1.logger.info(`  "${conflict.testName}": ${candidateStr}` +
+                        ` → skipped (conflict error)`);
+                }
+            }
+        }
+        // T098 — resolution suggestions for unmatched tests
+        if (unmatched > 0) {
+            logger_1.logger.info('');
+            logger_1.logger.info(`Resolution suggestions for ${unmatched} unmatched test(s):`);
+            if (annotationEnabled) {
+                logger_1.logger.info('  - Annotation: ensure @TestmoId:<case_id> is on the line immediately above the test function/method');
+            }
+            if (configMappingEnabled) {
+                logger_1.logger.info('  - Config mapping: add an entry to config_mappings:');
+                logger_1.logger.info('      test_name: "<test name>"');
+                logger_1.logger.info('      case_id: <case_id>');
+            }
+            if (patternEnabled) {
+                logger_1.logger.info('  - Pattern matching: add or refine a pattern_matching rule');
+            }
+            if (!annotationEnabled && !configMappingEnabled && !patternEnabled) {
+                logger_1.logger.info('  - Enable at least one linking method in your config file:');
+                logger_1.logger.info('      config_mappings, annotations, or pattern_matching');
+            }
+        }
+        if (options.failOnUnmatched && unmatched > 0) {
+            logger_1.logger.error(`Failing: ${unmatched} unmatched test(s) (--fail-on-unmatched)`);
+            return 1;
+        }
+        if (errors > 0) {
+            return 1;
+        }
+        return 0;
+    }
+}
+exports.AutomationLink = AutomationLink;