ado-sync 0.1.24 → 0.1.27

package/dist/azure/client.d.ts

@@ -1,4 +1,5 @@
 import * as CoreApi from 'azure-devops-node-api/CoreApi';
+import * as TestApi from 'azure-devops-node-api/TestApi';
 import * as TestPlanApi from 'azure-devops-node-api/TestPlanApi';
 import * as WorkItemTrackingApi from 'azure-devops-node-api/WorkItemTrackingApi';
 import { SyncConfig } from '../types';
@@ -7,11 +8,13 @@ export declare class AzureClient {
     private connection;
     private _witApi;
     private _testPlanApi;
+    private _testApi;
     private _coreApi;
     private constructor();
     static create(config: SyncConfig): Promise<AzureClient>;
     private connect;
     getWitApi(): Promise<WorkItemTrackingApi.IWorkItemTrackingApi>;
     getTestPlanApi(): Promise<TestPlanApi.ITestPlanApi>;
+    getTestApi(): Promise<TestApi.ITestApi>;
     getCoreApi(): Promise<CoreApi.ICoreApi>;
 }

package/dist/azure/client.js

@@ -42,6 +42,7 @@ class AzureClient {
     connection;
     _witApi;
     _testPlanApi;
+    _testApi;
     _coreApi;
     constructor(config) {
         this.config = config;
@@ -78,6 +79,11 @@ class AzureClient {
             this._testPlanApi = await this.connection.getTestPlanApi();
         return this._testPlanApi;
     }
+    async getTestApi() {
+        if (!this._testApi)
+            this._testApi = await this.connection.getTestApi();
+        return this._testApi;
+    }
     async getCoreApi() {
         if (!this._coreApi)
             this._coreApi = await this.connection.getCoreApi();

package/dist/azure/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/azure/client.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8CAAyD;AACzD,6DAA+C;AAC/C,iEAA+C;AAQ/C,MAAa,WAAW;IAMM;IALpB,UAAU,CAAU;IACpB,OAAO,CAA4C;IACnD,YAAY,CAA4B;IACxC,QAAQ,CAAoB;IAEpC,YAA4B,MAAkB;QAAlB,WAAM,GAAN,MAAM,CAAY;IAAG,CAAC;IAElD,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAkB;QACpC,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,OAAO;QACnB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QAErC,IAAI,WAA4B,CAAC;QAEjC,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YACpC,MAAM,UAAU,GAAG,IAAI,iCAAsB,EAAE,CAAC;YAChD,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAiB,CAAC,CAAC;YAChE,WAAW,GAAG,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACpD,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YACvC,WAAW,GAAG,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAM,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,MAAM;YACN,WAAW,GAAG,KAAK,CAAC,6BAA6B,CAAC,IAAI,CAAC,KAAM,CAAC,CAAC;QACjE,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,8BAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,sBAAsB,EAAE,CAAC;QACjF,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,IAAI,CAAC,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;QACnF,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;QACvE,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF;AA/CD,kCA+CC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/azure/client.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8CAAyD;AACzD,6DAA+C;AAC/C,iEAA+C;AAS/C,MAAa,WAAW;IAOM;IANpB,UAAU,CAAU;IACpB,OAAO,CAA4C;IACnD,YAAY,CAA4B;IACxC,QAAQ,CAAoB;IAC5B,QAAQ,CAAoB;IAEpC,YAA4B,MAAkB;QAAlB,WAAM,GAAN,MAAM,CAAY;IAAG,CAAC;IAElD,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAkB;QACpC,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,OAAO;QACnB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QAErC,IAAI,WAA4B,CAAC;QAEjC,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YACpC,MAAM,UAAU,GAAG,IAAI,iCAAsB,EAAE,CAAC;YAChD,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAiB,CAAC,CAAC;YAChE,WAAW,GAAG,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACpD,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YACvC,WAAW,GAAG,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAM,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,MAAM;YACN,WAAW,GAAG,KAAK,CAAC,6BAA6B,CAAC,IAAI,CAAC,KAAM,CAAC,CAAC;QACjE,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,8BAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,sBAAsB,EAAE,CAAC;QACjF,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,IAAI,CAAC,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;QACnF,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;QACvE,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;QACvE,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF;AArDD,kCAqDC"}

package/dist/azure/test-cases.d.ts

@@ -16,16 +16,21 @@
  * For Scenario Outlines, parameter data is stored in:
  *   Microsoft.VSTS.TCM.LocalDataSource  (NewDataSet XML)
  */
-import { AzureTestCase, ParsedTest, SyncConfig } from '../types';
+import { AzureTestCase, CustomizationsConfig, ParsedTest, SyncConfig } from '../types';
 import { AzureClient } from './client';
+/**
+ * Process tags for push: apply tag mapping and filter ignored tags.
+ * Returns the transformed tags list ready for Azure DevOps.
+ */
+export declare function processTagsForPush(tags: string[], tagPrefix: string, customizations?: CustomizationsConfig): string[];
 /**
  * Get or create a nested suite matching the folder path of the given file.
  * Uses suiteCache (Map<relPath, suiteId>) to avoid redundant API calls.
  */
 export declare function getOrCreateSuiteForFile(client: AzureClient, config: SyncConfig, filePath: string, configDir: string, suiteCache: Map<string, number>): Promise<number>;
 export declare function getTestCase(client: AzureClient, id: number, titleField?: string): Promise<AzureTestCase | null>;
-export declare function createTestCase(client: AzureClient, test: ParsedTest, config: SyncConfig, suiteIdOverride?: number): Promise<number>;
-export declare function updateTestCase(client: AzureClient, id: number, test: ParsedTest, config: SyncConfig): Promise<void>;
+export declare function createTestCase(client: AzureClient, test: ParsedTest, config: SyncConfig, suiteIdOverride?: number, configDir?: string): Promise<number>;
+export declare function updateTestCase(client: AzureClient, id: number, test: ParsedTest, config: SyncConfig, configDir?: string): Promise<void>;
 export declare function updateLocalFromAzure(client: AzureClient, id: number, titleField?: string): Promise<AzureTestCase | null>;
 /**
  * Tag an orphaned Azure TC with 'ado-sync:removed' so teams can review and

package/dist/azure/test-cases.js

@@ -54,6 +54,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTagsForPush = processTagsForPush;
 exports.getOrCreateSuiteForFile = getOrCreateSuiteForFile;
 exports.getTestCase = getTestCase;
 exports.createTestCase = createTestCase;
@@ -67,6 +68,8 @@ exports.getTestCasesInSuite = getTestCasesInSuite;
 const tag_expressions_1 = __importDefault(require("@cucumber/tag-expressions"));
 const crypto = __importStar(require("crypto"));
 const fast_xml_parser_1 = require("fast-xml-parser");
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
 const path = __importStar(require("path"));
 // ─── XML helpers ─────────────────────────────────────────────────────────────
 function escapeHtml(str) {
@@ -223,7 +226,9 @@ function buildAutomationPatches(test, config, op) {
     const ext = path.extname(test.filePath);
     const fileBase = sanitizeTestName(path.basename(test.filePath, ext));
     const scenarioName = sanitizeTestName(test.title);
-    const automatedTestName = `${fileBase}.${scenarioName}`;
+    // For C# tests, automatedTestName is the FQMN (Namespace.Class.Method) provided by the parser.
+    // For other types it falls back to the file-basename.scenario-title convention.
+    const automatedTestName = test.automatedTestName ?? `${fileBase}.${scenarioName}`;
     const automatedTestStorage = path.basename(test.filePath);
     const automatedTestId = deterministicGuid(`${test.filePath}::${test.title}`);
     return [
@@ -243,6 +248,354 @@ function tagsFromString(raw) {
         .map((t) => t.trim())
         .filter(Boolean);
 }
+// ─── Tag transformation helpers ──────────────────────────────────────────────
+/**
+ * Apply tag text map transformation (character/substring replacements).
+ * e.g. textMap { "_": " " } transforms "my_tag" → "my tag"
+ */
+function applyTagTextMap(tags, textMap) {
+    return tags.map((t) => {
+        let result = t;
+        for (const [from, to] of Object.entries(textMap)) {
+            result = result.split(from).join(to);
+        }
+        return result;
+    });
+}
+/**
+ * Filter tags that should be ignored from removal during push.
+ * Patterns support trailing wildcard (e.g. "ado-tag*").
+ */
+function isIgnoredTag(tag, ignorePatterns) {
+    for (const pattern of ignorePatterns) {
+        if (pattern.endsWith('*')) {
+            if (tag.startsWith(pattern.slice(0, -1)))
+                return true;
+        }
+        else if (tag === pattern) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Process tags for push: apply tag mapping and filter ignored tags.
+ * Returns the transformed tags list ready for Azure DevOps.
+ */
+function processTagsForPush(tags, tagPrefix, customizations) {
+    let processed = tags.filter((t) => !t.startsWith(tagPrefix + ':'));
+    // Apply tag text map transformation
+    if (customizations?.tagTextMapTransformation?.enabled && customizations.tagTextMapTransformation.textMap) {
+        processed = applyTagTextMap(processed, customizations.tagTextMapTransformation.textMap);
+    }
+    return processed;
+}
+// ─── State change helpers ────────────────────────────────────────────────────
+/**
+ * Build the PATCH operation to set the TC state when the scenario has changed.
+ * Only applies when state.setValueOnChangeTo is configured.
+ * Respects an optional state.condition tag expression.
+ */
+function buildStateChangePatches(test, stateConfig, op) {
+    if (!stateConfig?.setValueOnChangeTo)
+        return [];
+    // Check condition: if specified, only apply state change when tags match
+    if (stateConfig.condition) {
+        const tagsWithAt = test.tags.map((t) => (t.startsWith('@') ? t : `@${t}`));
+        const node = (0, tag_expressions_1.default)(stateConfig.condition);
+        if (!node.evaluate(tagsWithAt))
+            return [];
+    }
+    return [
+        { op, path: '/fields/System.State', value: stateConfig.setValueOnChangeTo },
+    ];
+}
+// ─── Field update helpers ────────────────────────────────────────────────────
+/**
+ * Expand placeholders in a field update value string.
+ * Supported placeholders:
+ *   {scenario-name} → test title
+ *   {feature-name}  → file basename without extension
+ *   {feature-file}  → file basename
+ *   {scenario-description} → test description
+ *   {1}, {2}, etc. → wildcard captures from condition
+ */
+function expandFieldPlaceholders(value, test, wildcardCaptures = []) {
+    let result = value;
+    result = result.replace(/\{scenario-name\}/g, test.title);
+    result = result.replace(/\{feature-name\}/g, path.basename(test.filePath, path.extname(test.filePath)));
+    result = result.replace(/\{feature-file\}/g, path.basename(test.filePath));
+    result = result.replace(/\{scenario-description\}/g, test.description ?? '');
+    // Replace numbered captures {1}, {2}, ...
+    for (let i = 0; i < wildcardCaptures.length; i++) {
+        result = result.replace(new RegExp(`\\{${i + 1}\\}`, 'g'), wildcardCaptures[i]);
+    }
+    return result;
+}
+/**
+ * Evaluate a tag condition with wildcard support.
+ * e.g. condition "@priority:*" with tags ["priority:high"] → captures: ["high"]
+ * Returns null if no match, or the array of wildcard captures if matched.
+ */
+function evaluateWildcardCondition(condition, tags) {
+    const tagsWithAt = tags.map((t) => (t.startsWith('@') ? t : `@${t}`));
+    // Check for wildcard patterns in the condition
+    if (!condition.includes('*')) {
+        // Simple tag expression evaluation
+        const node = (0, tag_expressions_1.default)(condition);
+        return node.evaluate(tagsWithAt) ? [] : null;
+    }
+    // Extract wildcard tag patterns from condition
+    const tagPatterns = condition.match(/@[\w-]+(?::[\w-]*\*[\w-]*)+|@[\w-]*\*[\w-]*/g) ?? [];
+    const captures = [];
+    for (const pattern of tagPatterns) {
+        const cleanPattern = pattern.startsWith('@') ? pattern.slice(1) : pattern;
+        // Convert wildcard pattern to regex: @priority:* → priority:(.+)
+        const regexStr = '^' + cleanPattern.replace(/\*/g, '(.+)') + '$';
+        const regex = new RegExp(regexStr);
+        let matched = false;
+        for (const tag of tags) {
+            const m = tag.match(regex);
+            if (m) {
+                captures.push(...m.slice(1));
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return null;
+    }
+    // Also evaluate the non-wildcard part of the expression
+    // Replace wildcard tags with a dummy tag name for expression evaluation
+    let evalExpr = condition;
+    for (const pattern of tagPatterns) {
+        evalExpr = evalExpr.replace(pattern, '@__wildcard_matched__');
+    }
+    // Add the dummy tag so it evaluates the rest of the expression correctly
+    const evalTags = [...tagsWithAt, '@__wildcard_matched__'];
+    try {
+        const node = (0, tag_expressions_1.default)(evalExpr);
+        if (!node.evaluate(evalTags))
+            return null;
+    }
+    catch {
+        // If the expression can't be parsed after replacement, trust the wildcard match
+    }
+    return captures;
+}
+/**
+ * Build PATCH operations for field updates.
+ * Handles simple values, conditional values, wildcard tag matches, and update events.
+ */
+function buildFieldUpdatePatches(test, fieldUpdates, isCreate, op) {
+    if (!fieldUpdates)
+        return [];
+    const patches = [];
+    for (const [field, spec] of Object.entries(fieldUpdates)) {
+        // Normalize field reference: if it doesn't contain a dot, assume it's a display name
+        const fieldPath = field.includes('.') ? field : field;
+        if (typeof spec === 'string') {
+            // Simple value — always update
+            const value = expandFieldPlaceholders(spec, test);
+            patches.push({ op, path: `/fields/${fieldPath}`, value });
+            continue;
+        }
+        const update = spec;
+        // Check update event
+        if (update.update === 'onCreate' && !isCreate)
+            continue;
+        if (update.update === 'onChange' && isCreate)
+            continue;
+        // Handle conditionalValue (switch-style)
+        if (update.conditionalValue) {
+            let resolved = false;
+            for (const [condExpr, condValue] of Object.entries(update.conditionalValue)) {
+                if (condExpr === 'otherwise')
+                    continue;
+                const captures = evaluateWildcardCondition(condExpr, test.tags);
+                if (captures !== null) {
+                    const value = expandFieldPlaceholders(condValue, test, captures);
+                    patches.push({ op, path: `/fields/${fieldPath}`, value });
+                    resolved = true;
+                    break;
+                }
+            }
+            if (!resolved && update.conditionalValue['otherwise'] !== undefined) {
+                const value = expandFieldPlaceholders(update.conditionalValue['otherwise'], test);
+                patches.push({ op, path: `/fields/${fieldPath}`, value });
+            }
+            continue;
+        }
+        // Handle single value with optional condition
+        if (update.condition) {
+            const captures = evaluateWildcardCondition(update.condition, test.tags);
+            if (captures === null)
+                continue;
+            if (update.value !== undefined) {
+                const value = expandFieldPlaceholders(update.value, test, captures);
+                patches.push({ op, path: `/fields/${fieldPath}`, value });
+            }
+        }
+        else if (update.value !== undefined) {
+            const value = expandFieldPlaceholders(update.value, test);
+            patches.push({ op, path: `/fields/${fieldPath}`, value });
+        }
+    }
+    return patches;
+}
+/**
+ * Build PATCH operations for field defaults (applied on create only).
+ */
+function buildFieldDefaultPatches(customizations) {
+    if (!customizations?.fieldDefaults?.enabled)
+        return [];
+    const patches = [];
+    for (const [field, value] of Object.entries(customizations.fieldDefaults.defaultValues)) {
+        patches.push({ op: 'add', path: `/fields/${field}`, value });
+    }
+    return patches;
+}
+// ─── Format helpers ──────────────────────────────────────────────────────────
+/**
+ * Apply format configuration to step conversion.
+ * Handles useExpectedResult, prefixBackgroundSteps, syncDataTableAsText, emptyActionValue, etc.
+ */
+function applyFormatToSteps(steps, formatConfig) {
+    const useExpected = formatConfig?.useExpectedResult ?? false;
+    const emptyAction = formatConfig?.emptyActionValue;
+    const emptyExpected = formatConfig?.emptyExpectedResultValue;
+    const prefixBg = formatConfig?.prefixBackgroundSteps ?? true;
+    const dataTableAsText = formatConfig?.syncDataTableAsText ?? false;
+    return steps
+        .filter((s) => {
+        // When prefixBackgroundSteps is false, exclude background steps entirely
+        if (s.isBackground && !prefixBg)
+            return false;
+        return true;
+    })
+        .map((s) => {
+        const bgPrefix = s.isBackground ? 'Background: ' : '';
+        const rawAction = `${bgPrefix}${s.keyword} ${s.text}`.trim();
+        let action = rawAction || emptyAction || '';
+        let expected = s.expected ?? '';
+        // When useExpectedResult is true, Then/Verify steps go to expected column
+        // (background steps are not subject to this transformation)
+        if (useExpected && !s.isBackground && (s.keyword === 'Then' || s.keyword === 'Verify')) {
+            expected = s.text;
+            action = emptyAction || '';
+        }
+        if (!expected && emptyExpected) {
+            expected = emptyExpected;
+        }
+        // Append data table rows as plain text when syncDataTableAsText is enabled
+        if (dataTableAsText && s.dataTable?.length) {
+            const tableText = s.dataTable.map((row) => `| ${row.join(' | ')} |`).join('\n');
+            action = action ? `${action}\n${tableText}` : tableText;
+        }
+        return { action, expected };
+    });
+}
+/**
+ * Optionally append a "Parameters: @p1@, @p2@, ..." step for parametrized TCs.
+ * The step is appended in-place to the steps array.
+ *
+ * - 'always'               → always append
+ * - 'never'                → never append
+ * - 'whenUnusedParameters' → append only when at least one header has no @param@ reference in any step (default)
+ */
+function applyShowParameterListStep(steps, outlineParameters, formatConfig) {
+    if (!outlineParameters?.headers.length)
+        return;
+    const mode = formatConfig?.showParameterListStep ?? 'whenUnusedParameters';
+    if (mode === 'never')
+        return;
+    const { headers } = outlineParameters;
+    const shouldAppend = mode === 'always' ||
+        headers.some((h) => !steps.some((s) => s.action.includes(`@${h}@`)));
+    if (shouldAppend) {
+        const paramsList = headers.map((h) => `@${h}@`).join(', ');
+        steps.push({ action: `Parameters: ${paramsList}`, expected: '' });
+    }
+}
+/**
+ * Apply prefixTitle format config to the test case title.
+ */
+function formatTitle(title, test, formatConfig) {
+    if (formatConfig?.prefixTitle === false)
+        return title;
+    // Don't double-prefix if title already has the prefix
+    if (/^Scenario(?:\s+Outline)?:\s+/i.test(title))
+        return title;
+    const isOutline = !!test.outlineParameters?.headers.length;
+    const prefix = isOutline ? 'Scenario Outline: ' : 'Scenario: ';
+    return prefix + title;
+}
+// ─── Attachment helpers ──────────────────────────────────────────────────────
+/**
+ * Upload file attachments to a test case work item.
+ * Resolves file paths relative to the feature file or the configured baseFolder.
+ */
+async function syncAttachments(client, tcId, test, config, configDir) {
+    const attachConfig = config.sync?.attachments;
+    if (!attachConfig?.enabled)
+        return;
+    if (!test.attachmentRefs?.length)
+        return;
+    const wit = await client.getWitApi();
+    const baseFolder = attachConfig.baseFolder
+        ? path.resolve(configDir, attachConfig.baseFolder)
+        : path.dirname(test.filePath);
+    // Fetch existing attachments on the TC
+    let existingAttachments = [];
+    try {
+        const wi = await wit.getWorkItem(tcId, undefined, undefined, 4 /* WorkItemExpand.Relations */);
+        if (wi?.relations) {
+            existingAttachments = wi.relations
+                .filter((r) => r.rel === 'AttachedFile')
+                .map((r) => ({
+                name: r.attributes?.name ?? '',
+                url: r.url ?? '',
+            }));
+        }
+    }
+    catch { /* continue without existing attachment info */ }
+    const existingNames = new Set(existingAttachments.map((a) => a.name));
+    for (const ref of test.attachmentRefs) {
+        // Resolve glob patterns for file paths
+        const resolvedPaths = await (0, glob_1.glob)(ref.filePath, {
+            cwd: baseFolder,
+            absolute: true,
+        });
+        for (const filePath of resolvedPaths) {
+            const fileName = path.basename(filePath);
+            if (existingNames.has(fileName))
+                continue; // Already attached
+            if (!fs.existsSync(filePath)) {
+                console.warn(`  [warn] Attachment file not found: ${filePath}`);
+                continue;
+            }
+            const content = fs.readFileSync(filePath);
+            const stream = Buffer.from(content);
+            try {
+                const attachment = await wit.createAttachment({}, stream, fileName);
+                if (attachment?.url) {
+                    await wit.updateWorkItem({}, [{
+                            op: 'add',
+                            path: '/relations/-',
+                            value: {
+                                rel: 'AttachedFile',
+                                url: attachment.url,
+                                attributes: { comment: `ado-sync:${ref.prefix}:${ref.filePath}` },
+                            },
+                        }], tcId);
+                }
+            }
+            catch (err) {
+                console.warn(`  [warn] Failed to attach ${fileName} to TC #${tcId}: ${err.message}`);
+            }
+        }
+    }
+}
 // ─── Work item relation helpers ───────────────────────────────────────────────
 function workItemUrl(orgUrl, id) {
     return `${orgUrl.replace(/\/$/, '')}/_apis/wit/workItems/${id}`;
@@ -422,26 +775,33 @@ async function getTestCase(client, id, titleField = 'System.Title') {
         iterationPath: f['System.IterationPath'],
     };
 }
-async function createTestCase(client, test, config, suiteIdOverride) {
+async function createTestCase(client, test, config, suiteIdOverride, configDir) {
     const wit = await client.getWitApi();
     const syncCfg = config.sync ?? {};
     const titleField = syncCfg.titleField ?? 'System.Title';
+    const formatConfig = syncCfg.format;
     const isParametrized = !!test.outlineParameters?.headers.length;
-    const steps = test.steps.map((s) => {
-        const rawAction = `${s.keyword} ${s.text}`.trim();
-        return {
-            action: isParametrized ? gherkinParamsToAzure(rawAction) : rawAction,
-            expected: s.expected ?? '',
-        };
-    });
+    const steps = applyFormatToSteps(test.steps, formatConfig).map((s) => ({
+        action: isParametrized ? gherkinParamsToAzure(s.action) : s.action,
+        expected: s.expected,
+    }));
+    applyShowParameterListStep(steps, test.outlineParameters, formatConfig);
+    // Apply format prefixTitle
+    const title = formatTitle(test.title, test, formatConfig);
     const patchDoc = [
-        { op: 'add', path: `/fields/${titleField}`, value: test.title },
+        { op: 'add', path: `/fields/${titleField}`, value: title },
         { op: 'add', path: '/fields/Microsoft.VSTS.TCM.Steps', value: buildStepsXml(steps) },
     ];
     if (test.description) {
         patchDoc.push({ op: 'add', path: '/fields/System.Description', value: test.description });
     }
     patchDoc.push(...buildAutomationPatches(test, config, 'add'));
+    // State change on create
+    patchDoc.push(...buildStateChangePatches(test, syncCfg.state, 'add'));
+    // Field defaults (customizations) — only on create
+    patchDoc.push(...buildFieldDefaultPatches(config.customizations));
+    // Field updates
+    patchDoc.push(...buildFieldUpdatePatches(test, syncCfg.fieldUpdates, true, 'add'));
     if (test.outlineParameters) {
         const { headers, rows } = test.outlineParameters;
         const namesXml = buildParameterNamesXml(headers);
@@ -453,9 +813,9 @@ async function createTestCase(client, test, config, suiteIdOverride) {
             patchDoc.push({ op: 'add', path: '/fields/Microsoft.VSTS.TCM.LocalDataSource', value: dataXml });
         }
     }
-    const filteredTags = test.tags
-        .filter((t) => !t.startsWith(syncCfg.tagPrefix + ':'))
-        .join('; ');
+    // Process tags: apply tag text map transformation
+    const processedTags = processTagsForPush(test.tags, syncCfg.tagPrefix ?? 'tc', config.customizations);
+    const filteredTags = processedTags.join('; ');
     if (filteredTags) {
         patchDoc.push({ op: 'add', path: '/fields/System.Tags', value: filteredTags });
     }
@@ -477,28 +837,41 @@ async function createTestCase(client, test, config, suiteIdOverride) {
     else {
         await addTestCaseToRootSuite(client, config, wi.id);
     }
+    // Sync attachments
+    if (configDir) {
+        await syncAttachments(client, wi.id, test, config, configDir);
+    }
     return wi.id;
 }
-async function updateTestCase(client, id, test, config) {
+async function updateTestCase(client, id, test, config, configDir) {
     const wit = await client.getWitApi();
     const syncCfg = config.sync ?? {};
     const titleField = syncCfg.titleField ?? 'System.Title';
+    const formatConfig = syncCfg.format;
     const isParametrized = !!test.outlineParameters?.headers.length;
-    const steps = test.steps.map((s) => {
-        const rawAction = `${s.keyword} ${s.text}`.trim();
-        return {
-            action: isParametrized ? gherkinParamsToAzure(rawAction) : rawAction,
-            expected: s.expected ?? '',
-        };
-    });
-    const localTags = test.tags.filter((t) => !t.startsWith(syncCfg.tagPrefix + ':'));
-    // Fetch existing Azure tags and merge: preserve any Azure-only tags, add new local tags
+    const steps = applyFormatToSteps(test.steps, formatConfig).map((s) => ({
+        action: isParametrized ? gherkinParamsToAzure(s.action) : s.action,
+        expected: s.expected,
+    }));
+    applyShowParameterListStep(steps, test.outlineParameters, formatConfig);
+    // Apply format prefixTitle
+    const title = formatTitle(test.title, test, formatConfig);
+    // Process tags with transformations
+    const processedLocalTags = processTagsForPush(test.tags, syncCfg.tagPrefix ?? 'tc', config.customizations);
+    // Fetch existing Azure tags and merge
     const wi = await wit.getWorkItem(id, ['System.Tags']);
     const existingAzureTags = tagsFromString(wi?.fields?.['System.Tags'] ?? '');
-    const mergedTags = [...new Set([...existingAzureTags, ...localTags])];
+    // Filter ignored tags from removal — they should be preserved in Azure
+    const ignorePatterns = config.customizations?.ignoreTestCaseTags?.enabled
+        ? config.customizations.ignoreTestCaseTags.tags
+        : [];
+    const mergedTags = [...new Set([
+            ...existingAzureTags.filter((t) => isIgnoredTag(t, ignorePatterns)),
+            ...processedLocalTags,
+        ])];
     const mergedTagsValue = mergedTags.join('; ');
     const patchDoc = [
-        { op: 'replace', path: `/fields/${titleField}`, value: test.title },
+        { op: 'replace', path: `/fields/${titleField}`, value: title },
         { op: 'replace', path: '/fields/Microsoft.VSTS.TCM.Steps', value: buildStepsXml(steps) },
         { op: 'replace', path: '/fields/System.Tags', value: mergedTagsValue },
     ];
@@ -506,6 +879,10 @@ async function updateTestCase(client, id, test, config) {
         patchDoc.push({ op: 'replace', path: '/fields/System.Description', value: test.description });
     }
     patchDoc.push(...buildAutomationPatches(test, config, 'replace'));
+    // State change on update
+    patchDoc.push(...buildStateChangePatches(test, syncCfg.state, 'replace'));
+    // Field updates
+    patchDoc.push(...buildFieldUpdatePatches(test, syncCfg.fieldUpdates, false, 'replace'));
     if (test.outlineParameters) {
         const { headers, rows } = test.outlineParameters;
         const namesXml = buildParameterNamesXml(headers);
@@ -521,6 +898,10 @@ async function updateTestCase(client, id, test, config) {
     const relationPatches = await applyLinkRelations(client, id, test, config, false);
     patchDoc.push(...relationPatches);
     await wit.updateWorkItem({}, patchDoc, id);
+    // Sync attachments
+    if (configDir) {
+        await syncAttachments(client, id, test, config, configDir);
+    }
 }
 async function updateLocalFromAzure(client, id, titleField) {
     return getTestCase(client, id, titleField);