@elisra-devops/docgen-data-provider 1.105.0 → 1.107.0

package/src/modules/TicketsDataProvider.ts

@@ -27,6 +27,58 @@ type DocTypeBranchConfig = {
   fallbackStart?: any;
 };
 
+type HistoricalQueryListItem = {
+  id: string;
+  queryName: string;
+  path: string;
+};
+
+type HistoricalWorkItemSnapshot = {
+  id: number;
+  workItemType: string;
+  title: string;
+  state: string;
+  areaPath: string;
+  iterationPath: string;
+  versionId: number | null;
+  versionTimestamp: string;
+  description: string;
+  steps: string;
+  testPhase: string;
+  relatedLinkCount: number;
+  workItemUrl: string;
+};
+
+type HistoricalSnapshotResult = {
+  queryId: string;
+  queryName: string;
+  asOf: string;
+  total: number;
+  rows: HistoricalWorkItemSnapshot[];
+  snapshotMap: Map<number, HistoricalWorkItemSnapshot>;
+};
+
+const HISTORICAL_WIT_API_VERSIONS: Array<string | null> = ['7.1', '5.1', null];
+const HISTORICAL_BATCH_MAX_IDS = 200;
+const HISTORICAL_WORK_ITEM_FIELDS = [
+  'System.Id',
+  'System.WorkItemType',
+  'System.Title',
+  'System.State',
+  'System.AreaPath',
+  'System.IterationPath',
+  'System.Rev',
+  'System.ChangedDate',
+  'System.Description',
+  'Microsoft.VSTS.TCM.Steps',
+  'Elisra.TestPhase',
+  'Custom.TestPhase',
+];
+
+/** Default fields fetched per work item in tree/flat query parsing. */
+const WI_DEFAULT_FIELDS =
+  'System.Description,System.Title,Microsoft.VSTS.TCM.ReproSteps,Microsoft.VSTS.CMMI.Symptom';
+
 export default class TicketsDataProvider {
   orgUrl: string = '';
   token: string = '';
@@ -187,12 +239,21 @@ export default class TicketsDataProvider {
    * @param docType document type
    * @returns
    */
+  private normalizeSharedQueriesPath(path: string): string {
+    const raw = String(path || '').trim();
+    if (!raw) return '';
+    const normalized = raw.toLowerCase();
+    if (normalized === 'shared' || normalized === 'shared queries') return '';
+    return raw;
+  }
+
   async GetSharedQueries(project: string, path: string, docType: string = ''): Promise<any> {
     let url;
     try {
-      if (path === '')
+      const normalizedPath = this.normalizeSharedQueriesPath(path);
+      if (normalizedPath === '')
         url = `${this.orgUrl}${project}/_apis/wit/queries/Shared%20Queries?$depth=2&$expand=all`;
-      else url = `${this.orgUrl}${project}/_apis/wit/queries/${path}?$depth=2&$expand=all`;
+      else url = `${this.orgUrl}${project}/_apis/wit/queries/${normalizedPath}?$depth=2&$expand=all`;
       let queries: any = await TFSServices.getItemContent(url, this.token);
       logger.debug(`doctype: ${docType}`);
       const normalizedDocType = (docType || '').toLowerCase();
@@ -201,8 +262,7 @@ export default class TicketsDataProvider {
       switch (normalizedDocType) {
         case 'std':
         case 'stp': {
-          const rootCandidates =
-            normalizedDocType === 'stp' ? (['stp', 'std'] as const) : (['std'] as const);
+          const rootCandidates = normalizedDocType === 'stp' ? (['stp', 'std'] as const) : (['std'] as const);
           let stdRoot = queriesWithChildren;
           let stdRootFound = false;
           for (const candidate of rootCandidates) {
@@ -216,7 +276,7 @@ export default class TicketsDataProvider {
           logger.debug(
             `[GetSharedQueries][${normalizedDocType}] using ${
               stdRootFound ? 'dedicated folder' : 'root queries'
-            }`
+            }`,
           );
           // Each branch describes the dedicated folder names, the fetch routine, and how to validate results.
           const stdBranches = await this.fetchDocTypeBranches(queriesWithChildren, stdRoot, [
@@ -271,7 +331,7 @@ export default class TicketsDataProvider {
         case 'str': {
           const { root: strRoot, found: strRootFound } = await this.getDocTypeRoot(
             queriesWithChildren,
-            'str'
+            'str',
           );
           logger.debug(`[GetSharedQueries][str] using ${strRootFound ? 'dedicated folder' : 'root queries'}`);
           const strBranches = await this.fetchDocTypeBranches(queriesWithChildren, strRoot, [
@@ -338,12 +398,12 @@ export default class TicketsDataProvider {
         case 'test-reporter': {
           const { root: testReporterRoot, found: testReporterFound } = await this.getDocTypeRoot(
             queriesWithChildren,
-            'test-reporter'
+            'test-reporter',
           );
           logger.debug(
             `[GetSharedQueries][test-reporter] using ${
               testReporterFound ? 'dedicated folder' : 'root queries'
-            }`
+            }`,
           );
           const testReporterBranches = await this.fetchDocTypeBranches(
             queriesWithChildren,
@@ -356,13 +416,15 @@ export default class TicketsDataProvider {
                 fetcher: (folder: any) => this.fetchTestReporterQueries(folder),
                 validator: (result: any) => this.hasAnyQueryTree(result?.testAssociatedTree),
               },
-            ]
+            ],
           );
           const testReporterFetch = testReporterBranches['testReporter'];
           return testReporterFetch?.result ?? { testAssociatedTree: null };
         }
         case 'srs':
           return await this.fetchSrsQueries(queriesWithChildren);
+        case 'sysrs':
+          return await this.fetchSysRsQueries(queriesWithChildren);
         case 'svd': {
           const { root: svdRoot, found } = await this.getDocTypeRoot(queriesWithChildren, 'svd');
           if (!found) {
@@ -399,6 +461,13 @@ export default class TicketsDataProvider {
             knownBugsQueryTree: knownBugsFetch?.result ?? null,
           };
         }
+        case 'historical-query':
+        case 'historical': {
+          const { tree1 } = await this.structureAllQueryPath(queriesWithChildren);
+          return {
+            historicalQueryTree: tree1 ? [tree1] : [],
+          };
+        }
         default:
           break;
       }
@@ -429,7 +498,7 @@ export default class TicketsDataProvider {
               field.name !== 'Title' &&
               field.name !== 'Description' &&
               field.name !== 'Work Item Type' &&
-              field.name !== 'Steps'
+              field.name !== 'Steps',
           )
           .map((field: any) => {
             return {
@@ -456,7 +525,7 @@ export default class TicketsDataProvider {
       onlyTestReq,
       null,
       ['Requirement'],
-      ['Test Case']
+      ['Test Case'],
     );
     return { reqTestTree, testReqTree };
   }
@@ -489,7 +558,7 @@ export default class TicketsDataProvider {
         'Review',
         'Test Plan',
         'Test Suite',
-      ]
+      ],
     );
     return { linkedMomTree };
   }
@@ -545,7 +614,7 @@ export default class TicketsDataProvider {
       onlySourceSide,
       null,
       ['Bug', 'Change Request'],
-      ['Test Case']
+      ['Test Case'],
     );
     return { OpenPcrToTestTree, TestToOpenPcrTree };
   }
@@ -561,7 +630,7 @@ export default class TicketsDataProvider {
       true,
       null,
       ['Requirement', 'Bug', 'Change Request'],
-      ['Test Case']
+      ['Test Case'],
     );
     return { testAssociatedTree };
   }
@@ -591,7 +660,7 @@ export default class TicketsDataProvider {
       undefined,
       true, // Enable processing of both tree and direct link queries, including flat queries
       excludedFolderNames,
-      true
+      true,
     );
     return { systemRequirementsQueryTree };
   }
@@ -617,19 +686,17 @@ export default class TicketsDataProvider {
 
     const systemToSoftwareFolder = await this.findChildFolderByName(
       srsFolderWithChildren,
-      'System to Software'
+      'System to Software',
     );
     const softwareToSystemFolder = await this.findChildFolderByName(
       srsFolderWithChildren,
-      'Software to System'
+      'Software to System',
     );
 
-    const systemToSoftwareRequirementsQueries = await this.fetchRequirementsTraceQueriesForFolder(
-      systemToSoftwareFolder
-    );
-    const softwareToSystemRequirementsQueries = await this.fetchRequirementsTraceQueriesForFolder(
-      softwareToSystemFolder
-    );
+    const systemToSoftwareRequirementsQueries =
+      await this.fetchRequirementsTraceQueriesForFolder(systemToSoftwareFolder);
+    const softwareToSystemRequirementsQueries =
+      await this.fetchRequirementsTraceQueriesForFolder(softwareToSystemFolder);
 
     return {
       systemRequirementsQueries,
@@ -638,6 +705,40 @@ export default class TicketsDataProvider {
     };
   }
 
+  private async fetchSysRsQueries(rootQueries: any) {
+    const { root: sysRsRoot, found: sysRsRootFound } = await this.getDocTypeRoot(rootQueries, 'sysrs');
+    logger.debug(`[GetSharedQueries][sysrs] using ${sysRsRootFound ? 'dedicated folder' : 'root queries'}`);
+
+    const systemRequirementsQueries = await this.fetchSystemRequirementQueries(sysRsRoot, [
+      'System To Customer',
+      'System To Subsystem',
+    ]);
+
+    const systemToCustomerFolder = await this.findChildFolderByPossibleNames(sysRsRoot, [
+      'system to customer',
+      'system-to-customer',
+      'system customer',
+      'subsystem to system',
+      'customer to system',
+    ]);
+    const systemToSubsystemFolder = await this.findChildFolderByPossibleNames(sysRsRoot, [
+      'system to subsystem',
+      'system-to-subsystem',
+      'system subsystem',
+    ]);
+
+    const subsystemToSystemRequirementsQueries =
+      await this.fetchRequirementsTraceQueriesForFolder(systemToCustomerFolder);
+    const systemToSubsystemRequirementsQueries =
+      await this.fetchRequirementsTraceQueriesForFolder(systemToSubsystemFolder);
+
+    return {
+      systemRequirementsQueries,
+      subsystemToSystemRequirementsQueries,
+      systemToSubsystemRequirementsQueries,
+    };
+  }
+
   /**
    * Fetches and structures linked queries related to requirements traceability with area path filtering.
    *
@@ -662,7 +763,7 @@ export default class TicketsDataProvider {
         ['epic', 'feature', 'requirement'],
         ['epic', 'feature', 'requirement'],
         'sys', // Source area filter for tree1: System area paths
-        'soft' // Target area filter for tree1: Software area paths (tree2 will be reversed automatically)
+        'soft', // Target area filter for tree1: Software area paths (tree2 will be reversed automatically)
       );
     return { SystemToSoftwareRequirementsTree, SoftwareToSystemRequirementsTree };
   }
@@ -680,7 +781,7 @@ export default class TicketsDataProvider {
       ['epic', 'feature', 'requirement'],
       undefined,
       undefined,
-      true
+      true,
     );
     return tree1;
   }
@@ -727,7 +828,7 @@ export default class TicketsDataProvider {
     const normalizedName = childName.toLowerCase();
     return (
       parentWithChildren.children.find(
-        (child: any) => child.isFolder && (child.name || '').toLowerCase() === normalizedName
+        (child: any) => child.isFolder && (child.name || '').toLowerCase() === normalizedName,
       ) || null
     );
   }
@@ -836,7 +937,7 @@ export default class TicketsDataProvider {
     startingFolder: any,
     fetcher: (folder: any) => Promise<any>,
     logContext: string,
-    validator?: (result: any) => boolean
+    validator?: (result: any) => boolean,
   ): Promise<{ result: any; usedFolder: any }> {
     const rootWithChildren = await this.ensureQueryChildren(rootQueries);
     const candidates = await this.buildFallbackChain(rootWithChildren, startingFolder);
@@ -870,7 +971,7 @@ export default class TicketsDataProvider {
   private async fetchDocTypeBranches(
     queriesWithChildren: any,
     docRoot: any,
-    branches: DocTypeBranchConfig[]
+    branches: DocTypeBranchConfig[],
   ): Promise<Record<string, FallbackFetchOutcome>> {
     const results: Record<string, FallbackFetchOutcome> = {};
     const effectiveDocRoot = docRoot ?? queriesWithChildren;
@@ -884,7 +985,7 @@ export default class TicketsDataProvider {
       if (branch.folderNames?.length && effectiveDocRoot) {
         const resolvedFolder = await this.findChildFolderByPossibleNames(
           effectiveDocRoot,
-          branch.folderNames
+          branch.folderNames,
         );
         if (resolvedFolder) {
           startingFolder = resolvedFolder;
@@ -899,7 +1000,7 @@ export default class TicketsDataProvider {
         startingFolder,
         branch.fetcher,
         branch.label,
-        branch.validator
+        branch.validator,
       );
 
       logger.debug(`${branch.label} final folder: ${fetchOutcome.usedFolder?.name ?? '<root>'}`);
@@ -955,7 +1056,7 @@ export default class TicketsDataProvider {
   private async findPathToNode(
     currentNode: any,
     targetId: string,
-    visited: Set<string> = new Set<string>()
+    visited: Set<string> = new Set<string>(),
   ): Promise<any[] | null> {
     if (!currentNode) {
       return null;
@@ -989,7 +1090,7 @@ export default class TicketsDataProvider {
 
   private async getDocTypeRoot(
     rootQueries: any,
-    docTypeName: string
+    docTypeName: string,
   ): Promise<{ root: any; found: boolean }> {
     if (!rootQueries) {
       return { root: rootQueries, found: false };
@@ -1022,7 +1123,8 @@ export default class TicketsDataProvider {
   async GetQueryResultsFromWiql(
     wiqlHref: string = '',
     displayAsTable: boolean = false,
-    testCaseToRelatedWiMap: Map<number, Set<any>>
+    testCaseToRelatedWiMap: Map<number, Set<any>>,
+    fetchAllFields: boolean = false,
   ): Promise<any> {
     try {
       if (!wiqlHref) {
@@ -1038,13 +1140,13 @@ export default class TicketsDataProvider {
         case QueryType.OneHop:
           return displayAsTable
             ? await this.parseDirectLinkedQueryResultForTableFormat(queryResult, testCaseToRelatedWiMap)
-            : await this.parseTreeQueryResult(queryResult);
+            : await this.parseTreeQueryResult(queryResult, fetchAllFields);
         case QueryType.Tree:
-          return await this.parseTreeQueryResult(queryResult);
+          return await this.parseTreeQueryResult(queryResult, fetchAllFields);
         case QueryType.Flat:
           return displayAsTable
             ? await this.parseFlatQueryResultForTableFormat(queryResult)
-            : await this.parseFlatQueryResult(queryResult);
+            : await this.parseFlatQueryResult(queryResult, fetchAllFields);
         default:
           break;
       }
@@ -1055,7 +1157,7 @@ export default class TicketsDataProvider {
 
   private async parseDirectLinkedQueryResultForTableFormat(
     queryResult: QueryTree,
-    testCaseToRelatedWiMap: Map<number, Set<any>>
+    testCaseToRelatedWiMap: Map<number, Set<any>>,
   ) {
     const { columns, workItemRelations } = queryResult;
 
@@ -1104,17 +1206,17 @@ export default class TicketsDataProvider {
       const allSourcePromises = Array.from(sourceIds).map((id) =>
         this.limit(() => {
           const relation = workItemRelations.find(
-            (r) => (!r.source && r.target.id === id) || r.source?.id === id
+            (r) => (!r.source && r.target.id === id) || r.source?.id === id,
           );
           return this.fetchWIForQueryResult(relation, columnsToShowMap, columnSourceMap, true);
-        })
+        }),
       );
 
       const allTargetPromises = Array.from(targetIds).map((id) =>
         this.limit(() => {
           const relation = workItemRelations.find((r) => r.target?.id === id);
           return this.fetchWIForQueryResult(relation, columnsToShowMap, columnTargetsMap, true);
-        })
+        }),
       );
 
       // Wait for all fetches to complete in parallel (with concurrency control)
@@ -1188,7 +1290,7 @@ export default class TicketsDataProvider {
   private mapTestCaseToRelatedItem(
     sourceWi: any,
     targetWi: any,
-    testCaseToRelatedItemMap: Map<number, Set<any>>
+    testCaseToRelatedItemMap: Map<number, Set<any>>,
   ) {
     if (sourceWi.fields['System.WorkItemType'] == 'Test Case') {
       if (!testCaseToRelatedItemMap.has(sourceWi.id)) {
@@ -1230,7 +1332,7 @@ export default class TicketsDataProvider {
     const wiSet: Set<any> = new Set();
     if (workItems) {
       const fetchPromises = workItems.map((workItem) =>
-        this.limit(() => this.fetchWIForQueryResult(workItem, columnsToShowMap, fieldsToIncludeMap, false))
+        this.limit(() => this.fetchWIForQueryResult(workItem, columnsToShowMap, fieldsToIncludeMap, false)),
       );
 
       const fetchedWorkItems = await Promise.all(fetchPromises);
@@ -1244,7 +1346,7 @@ export default class TicketsDataProvider {
     };
   }
 
-  private async parseTreeQueryResult(queryResult: QueryTree) {
+  private async parseTreeQueryResult(queryResult: QueryTree, fetchAllFields: boolean = false) {
     const { workItemRelations } = queryResult;
     if (!workItemRelations) return null;
 
@@ -1258,11 +1360,11 @@ export default class TicketsDataProvider {
     // This ensures nodes with non-hierarchy links are also available
     for (const rel of workItemRelations) {
       const t = rel.target;
-      if (!allItems[t.id]) await this.initTreeQueryResultItem(t, allItems);
+      if (!allItems[t.id]) await this.initTreeQueryResultItem(t, allItems, fetchAllFields);
 
       // Also initialize source nodes if they exist
       if (rel.source && !allItems[rel.source.id]) {
-        await this.initTreeQueryResultItem(rel.source, allItems);
+        await this.initTreeQueryResultItem(rel.source, allItems, fetchAllFields);
       }
 
       if (rel.rel === null && rel.source === null) {
@@ -1273,7 +1375,7 @@ export default class TicketsDataProvider {
       }
     }
     logger.debug(
-      `parseTreeQueryResult: Found ${rootOrder.length} roots, ${Object.keys(allItems).length} total nodes`
+      `parseTreeQueryResult: Found ${rootOrder.length} roots, ${Object.keys(allItems).length} total nodes`,
     );
 
     // Attach only forward hierarchy edges; dedupe children by id per parent
@@ -1293,11 +1395,11 @@ export default class TicketsDataProvider {
       // Nodes should already be initialized, but double-check
       if (!allItems[parentId]) {
         logger.warn(`Parent ${parentId} not found, initializing now`);
-        await this.initTreeQueryResultItem(rel.source, allItems);
+        await this.initTreeQueryResultItem(rel.source, allItems, fetchAllFields);
       }
       if (!allItems[childId]) {
         logger.warn(`Child ${childId} not found, initializing now`);
-        await this.initTreeQueryResultItem(rel.target, allItems);
+        await this.initTreeQueryResultItem(rel.target, allItems, fetchAllFields);
       }
 
       const parent = allItems[parentId];
@@ -1313,13 +1415,13 @@ export default class TicketsDataProvider {
       }
     }
     logger.debug(
-      `parseTreeQueryResult: ${hierarchyCount} hierarchy links, ${skippedNonHierarchy} non-hierarchy links skipped`
+      `parseTreeQueryResult: ${hierarchyCount} hierarchy links, ${skippedNonHierarchy} non-hierarchy links skipped`,
     );
 
     // Return roots in original order, excluding those that became children
     const roots = rootOrder.filter((id) => rootSet.has(id)).map((id) => allItems[id]);
     logger.debug(
-      `parseTreeQueryResult: Returning ${roots.length} roots with ${Object.keys(allItems).length} total items`
+      `parseTreeQueryResult: Returning ${roots.length} roots with ${Object.keys(allItems).length} total items`,
     );
 
     // Optional: clean helper sets
@@ -1332,32 +1434,42 @@ export default class TicketsDataProvider {
     };
   }
 
-  private async initTreeQueryResultItem(item: any, allItems: any) {
-    const urlWi = `${item.url}?fields=System.Description,System.Title,Microsoft.VSTS.TCM.ReproSteps,Microsoft.VSTS.CMMI.Symptom`;
+  private async initTreeQueryResultItem(item: any, allItems: any, fetchAllFields: boolean = false) {
+    const urlWi = fetchAllFields ? `${item.url}` : `${item.url}?fields=${WI_DEFAULT_FIELDS}`;
     const wi = await TFSServices.getItemContent(urlWi, this.token);
+    const fields = wi?.fields || {};
     // need to fetch the WI with only the the title, the web URL and the description
     allItems[item.id] = {
       id: item.id,
-      title: wi.fields['System.Title'] || '',
-      description: wi.fields['Microsoft.VSTS.CMMI.Symptom'] ?? wi.fields['System.Description'] ?? '',
+      title: fields['System.Title'] || '',
+      description: fields['Microsoft.VSTS.CMMI.Symptom'] ?? fields['System.Description'] ?? '',
       htmlUrl: wi._links.html.href,
+      fields,
+      workItemType: fields['System.WorkItemType'] || '',
       children: [],
     };
   }
 
-  private async initFlatQueryResultItem(item: any, workItemMap: Map<number, any>) {
-    const urlWi = `${item.url}?fields=System.Description,System.Title,Microsoft.VSTS.TCM.ReproSteps,Microsoft.VSTS.CMMI.Symptom`;
+  private async initFlatQueryResultItem(
+    item: any,
+    workItemMap: Map<number, any>,
+    fetchAllFields: boolean = false,
+  ) {
+    const urlWi = fetchAllFields ? `${item.url}` : `${item.url}?fields=${WI_DEFAULT_FIELDS}`;
     const wi = await TFSServices.getItemContent(urlWi, this.token);
+    const fields = wi?.fields || {};
     // need to fetch the WI with only the the title, the web URL and the description
     workItemMap.set(item.id, {
       id: item.id,
-      title: wi.fields['System.Title'] || '',
-      description: wi.fields['Microsoft.VSTS.CMMI.Symptom'] ?? wi.fields['System.Description'] ?? '',
+      title: fields['System.Title'] || '',
+      description: fields['Microsoft.VSTS.CMMI.Symptom'] ?? fields['System.Description'] ?? '',
       htmlUrl: wi._links.html.href,
+      fields,
+      workItemType: fields['System.WorkItemType'] || '',
     });
   }
 
-  private async parseFlatQueryResult(queryResult: QueryTree) {
+  private async parseFlatQueryResult(queryResult: QueryTree, fetchAllFields: boolean = false) {
     const { workItems } = queryResult;
     if (!workItems) {
       logger.warn(`No work items were found for this requested query`);
@@ -1368,7 +1480,7 @@ export default class TicketsDataProvider {
       const workItemsResultMap: Map<number, any> = new Map();
       for (const wi of workItems) {
         if (!workItemsResultMap.has(wi.id)) {
-          await this.initFlatQueryResultItem(wi, workItemsResultMap);
+          await this.initFlatQueryResultItem(wi, workItemsResultMap, fetchAllFields);
         }
       }
       return [...workItemsResultMap.values()];
@@ -1381,7 +1493,7 @@ export default class TicketsDataProvider {
     receivedObject: any,
     columnMap: Map<string, string>,
     resultedRefNameMap: Map<string, string>,
-    isRelation: boolean
+    isRelation: boolean,
   ) {
     const url = isRelation ? `${receivedObject.target.url}` : `${receivedObject.url}`;
     const wi: any = await TFSServices.getItemContent(url, this.token);
@@ -1414,7 +1526,7 @@ export default class TicketsDataProvider {
       if (modeledResult.queryType == 'tree') {
         let levelResults: Array<Workitem> = Helper.LevelBuilder(
           modeledResult,
-          modeledResult.workItems[0].fields[0].value
+          modeledResult.workItems[0].fields[0].value,
         );
         return levelResults;
       }
@@ -1442,6 +1554,597 @@ export default class TicketsDataProvider {
     return await this.GetQueryResultsByWiqlHref(wiql.href, project);
   }
 
+  private normalizeHistoricalAsOf(value: string): string {
+    const raw = String(value || '').trim();
+    if (!raw) {
+      throw new Error('asOf date-time is required');
+    }
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+      throw new Error(`Invalid date-time value: ${raw}`);
+    }
+    return parsed.toISOString();
+  }
+
+  private normalizeHistoricalCompareValue(value: unknown): string {
+    if (value == null) {
+      return '';
+    }
+    if (typeof value === 'string') {
+      return value.replace(/\s+/g, ' ').trim();
+    }
+    if (Array.isArray(value)) {
+      return value
+        .map((item) => this.normalizeHistoricalCompareValue(item))
+        .filter((item) => item !== '')
+        .sort((a, b) => a.localeCompare(b))
+        .join('; ');
+    }
+    if (typeof value === 'object') {
+      const fallback = value as Record<string, unknown>;
+      if (typeof fallback.displayName === 'string') {
+        return this.normalizeHistoricalCompareValue(fallback.displayName);
+      }
+      if (typeof fallback.name === 'string') {
+        return this.normalizeHistoricalCompareValue(fallback.name);
+      }
+      return this.normalizeHistoricalCompareValue(JSON.stringify(value));
+    }
+    return String(value).trim();
+  }
+
+  private normalizeTestPhaseValue(value: unknown): string {
+    const rendered = this.normalizeHistoricalCompareValue(value);
+    if (!rendered) {
+      return '';
+    }
+    const parts = rendered
+      .split(/[;,]/)
+      .map((part) => part.trim())
+      .filter((part) => part.length > 0);
+    if (parts.length <= 1) {
+      return rendered;
+    }
+    const unique = Array.from(new Set(parts));
+    unique.sort((a, b) => a.localeCompare(b));
+    return unique.join('; ');
+  }
+
+  private isTestCaseType(workItemType: string): boolean {
+    const normalized = String(workItemType || '').trim().toLowerCase();
+    return normalized === 'test case' || normalized === 'testcase';
+  }
+
+  private toHistoricalRevision(value: unknown): number | null {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+      return null;
+    }
+    return n;
+  }
+
+  private extractHistoricalWorkItemIds(queryResult: any): number[] {
+    const ids = new Set<number>();
+
+    const pushId = (candidate: unknown) => {
+      const n = Number(candidate);
+      if (Number.isFinite(n)) {
+        ids.add(n);
+      }
+    };
+
+    const workItems = Array.isArray(queryResult?.workItems) ? queryResult.workItems : [];
+    for (const workItem of workItems) {
+      pushId(workItem?.id);
+    }
+
+    const workItemRelations = Array.isArray(queryResult?.workItemRelations)
+      ? queryResult.workItemRelations
+      : [];
+    for (const relation of workItemRelations) {
+      pushId(relation?.source?.id);
+      pushId(relation?.target?.id);
+    }
+
+    return Array.from(ids.values()).sort((a, b) => a - b);
+  }
+
+  private appendAsOfToWiql(wiql: string, asOfIso: string): string {
+    const raw = String(wiql || '').trim();
+    if (!raw) {
+      return '';
+    }
+    const withoutAsOf = raw.replace(/\s+ASOF\s+'[^']*'/i, '');
+    return `${withoutAsOf} ASOF '${asOfIso}'`;
+  }
+
+  private appendApiVersion(url: string, apiVersion: string | null): string {
+    if (!apiVersion) {
+      return url;
+    }
+    const separator = url.includes('?') ? '&' : '?';
+    return `${url}${separator}api-version=${encodeURIComponent(apiVersion)}`;
+  }
+
+  private shouldRetryHistoricalWithLowerVersion(error: any): boolean {
+    const status = Number(error?.response?.status || 0);
+    if (status === 401 || status === 403) {
+      return false;
+    }
+    if (status >= 500) {
+      return true;
+    }
+    if ([400, 404, 405, 406, 410].includes(status)) {
+      return true;
+    }
+    const message = String(error?.response?.data?.message || error?.message || '');
+    return /api[- ]?version/i.test(message);
+  }
+
+  private async withHistoricalApiVersionFallback<T>(
+    operation: string,
+    task: (apiVersion: string | null) => Promise<T>,
+  ): Promise<{ apiVersion: string | null; result: T }> {
+    let lastError: any = null;
+    for (const apiVersion of HISTORICAL_WIT_API_VERSIONS) {
+      try {
+        const result = await task(apiVersion);
+        return { apiVersion, result };
+      } catch (error: any) {
+        lastError = error;
+        const status = Number(error?.response?.status || 0);
+        const apiVersionLabel = apiVersion || 'default';
+        logger.warn(
+          `[${operation}] failed with api-version=${apiVersionLabel}${status ? ` (status ${status})` : ''}`,
+        );
+        if (
+          !this.shouldRetryHistoricalWithLowerVersion(error) ||
+          apiVersion === HISTORICAL_WIT_API_VERSIONS[HISTORICAL_WIT_API_VERSIONS.length - 1]
+        ) {
+          throw error;
+        }
+      }
+    }
+    throw lastError || new Error(`[${operation}] Failed to execute historical request`);
+  }
+
+  private chunkHistoricalWorkItemIds(ids: number[]): number[][] {
+    const chunks: number[][] = [];
+    for (let i = 0; i < ids.length; i += HISTORICAL_BATCH_MAX_IDS) {
+      chunks.push(ids.slice(i, i + HISTORICAL_BATCH_MAX_IDS));
+    }
+    return chunks;
+  }
+
+  private normalizeHistoricalQueryPath(path: string): string {
+    const rawPath = String(path || '').trim();
+    const normalizedRoot = rawPath.toLowerCase();
+    if (
+      rawPath === '' ||
+      normalizedRoot === 'shared' ||
+      normalizedRoot === 'shared queries'
+    ) {
+      return 'Shared%20Queries';
+    }
+
+    const segments = rawPath
+      .replace(/\\/g, '/')
+      .split('/')
+      .filter((segment) => segment.trim() !== '')
+      .map((segment) => {
+        try {
+          return encodeURIComponent(decodeURIComponent(segment));
+        } catch (error) {
+          return encodeURIComponent(segment);
+        }
+      });
+    return segments.join('/');
+  }
+
+  private normalizeHistoricalQueryRoot(root: any): any {
+    if (!root) return root;
+    if (Array.isArray(root?.children) || typeof root?.isFolder === 'boolean') {
+      return root;
+    }
+    if (Array.isArray(root?.value)) {
+      return {
+        id: 'root',
+        name: 'Shared Queries',
+        isFolder: true,
+        children: root.value,
+      };
+    }
+    return root;
+  }
+
+  private async fetchHistoricalWorkItemsBatch(
+    project: string,
+    ids: number[],
+    asOf: string,
+    apiVersion: string | null,
+  ): Promise<any[]> {
+    const workItemsBatchUrl = this.appendApiVersion(
+      `${this.orgUrl}${project}/_apis/wit/workitemsbatch`,
+      apiVersion,
+    );
+    const idChunks = this.chunkHistoricalWorkItemIds(ids);
+    try {
+      const batchResponses = await Promise.all(
+        idChunks.map((idChunk) =>
+          this.limit(() =>
+            TFSServices.getItemContent(workItemsBatchUrl, this.token, 'post', {
+              ids: idChunk,
+              asOf,
+              $expand: 'Relations',
+              fields: HISTORICAL_WORK_ITEM_FIELDS,
+            }),
+          ),
+        ),
+      );
+      return batchResponses.flatMap((batch) => (Array.isArray(batch?.value) ? batch.value : []));
+    } catch (error: any) {
+      logger.warn(
+        `[historical-workitems] workitemsbatch failed${
+          apiVersion ? ` (api-version=${apiVersion})` : ''
+        }, falling back to per-item retrieval: ${error?.message || error}`,
+      );
+      const asOfParam = encodeURIComponent(asOf);
+      const responses = await Promise.all(
+        ids.map((id) =>
+          this.limit(() => {
+            const itemUrl = this.appendApiVersion(
+              `${this.orgUrl}${project}/_apis/wit/workitems/${id}?$expand=Relations&asOf=${asOfParam}`,
+              apiVersion,
+            );
+            return TFSServices.getItemContent(itemUrl, this.token);
+          }),
+        ),
+      );
+      return responses.filter((item) => item && typeof item === 'object');
+    }
+  }
+
+  private async executeHistoricalQueryAtAsOf(
+    project: string,
+    queryId: string,
+    asOfIso: string,
+  ): Promise<{ queryDefinition: any; queryResult: any; apiVersion: string | null }> {
+    const { apiVersion, result } = await this.withHistoricalApiVersionFallback(
+      'historical-query-execution',
+      async (resolvedApiVersion) => {
+        const queryDefUrl = this.appendApiVersion(
+          `${this.orgUrl}${project}/_apis/wit/queries/${encodeURIComponent(queryId)}?$expand=all`,
+          resolvedApiVersion,
+        );
+        const queryDefinition = await TFSServices.getItemContent(queryDefUrl, this.token);
+
+        const wiqlText = String(queryDefinition?.wiql || '').trim();
+        let queryResult: any = null;
+        try {
+          if (!wiqlText) {
+            throw new Error(`Could not resolve WIQL text for query ${queryId}`);
+          }
+          const wiqlWithAsOf = this.appendAsOfToWiql(wiqlText, asOfIso);
+          if (!wiqlWithAsOf) {
+            throw new Error(`Could not build WIQL for historical query ${queryId}`);
+          }
+          const executeUrl = this.appendApiVersion(
+            `${this.orgUrl}${project}/_apis/wit/wiql?$top=2147483646&timePrecision=true`,
+            resolvedApiVersion,
+          );
+          queryResult = await TFSServices.getItemContent(executeUrl, this.token, 'post', {
+            query: wiqlWithAsOf,
+          });
+        } catch (inlineWiqlError: any) {
+          logger.warn(
+            `[historical-query-execution] inline WIQL failed for query ${queryId}${
+              resolvedApiVersion ? ` (api-version=${resolvedApiVersion})` : ''
+            }, trying WIQL-by-id fallback: ${inlineWiqlError?.message || inlineWiqlError}`,
+          );
+          const executeByIdUrl = this.appendApiVersion(
+            `${this.orgUrl}${project}/_apis/wit/wiql/${encodeURIComponent(
+              queryId,
+            )}?$top=2147483646&timePrecision=true&asOf=${encodeURIComponent(asOfIso)}`,
+            resolvedApiVersion,
+          );
+          queryResult = await TFSServices.getItemContent(executeByIdUrl, this.token);
+        }
+        return { queryDefinition, queryResult };
+      },
+    );
+    return { ...result, apiVersion };
+  }
+
+  private toHistoricalWorkItemSnapshot(project: string, workItem: any): HistoricalWorkItemSnapshot {
+    const fields = (workItem?.fields || {}) as Record<string, unknown>;
+    const id = Number(workItem?.id || fields['System.Id'] || 0);
+    const workItemType = this.normalizeHistoricalCompareValue(fields['System.WorkItemType']);
+    const testPhaseRaw =
+      fields['Elisra.TestPhase'] ??
+      fields['Custom.TestPhase'] ??
+      fields['Elisra.Testphase'] ??
+      fields['Custom.Testphase'];
+    const relatedLinkCount = Array.isArray(workItem?.relations) ? workItem.relations.length : 0;
+
+    return {
+      id,
+      workItemType,
+      title: this.normalizeHistoricalCompareValue(fields['System.Title']),
+      state: this.normalizeHistoricalCompareValue(fields['System.State']),
+      areaPath: this.normalizeHistoricalCompareValue(fields['System.AreaPath']),
+      iterationPath: this.normalizeHistoricalCompareValue(fields['System.IterationPath']),
+      versionId: this.toHistoricalRevision(workItem?.rev ?? fields['System.Rev']),
+      versionTimestamp: this.normalizeHistoricalCompareValue(fields['System.ChangedDate']),
+      description: this.normalizeHistoricalCompareValue(fields['System.Description']),
+      steps: this.normalizeHistoricalCompareValue(fields['Microsoft.VSTS.TCM.Steps']),
+      testPhase: this.normalizeTestPhaseValue(testPhaseRaw),
+      relatedLinkCount,
+      workItemUrl: `${this.orgUrl}${project}/_workitems/edit/${id}`,
+    };
+  }
+
+  private async getHistoricalSnapshot(
+    project: string,
+    queryId: string,
+    asOfInput: string,
+  ): Promise<HistoricalSnapshotResult> {
+    const asOf = this.normalizeHistoricalAsOf(asOfInput);
+    const { queryDefinition, queryResult, apiVersion } = await this.executeHistoricalQueryAtAsOf(
+      project,
+      queryId,
+      asOf,
+    );
+    const ids = this.extractHistoricalWorkItemIds(queryResult);
+
+    if (ids.length === 0) {
+      return {
+        queryId,
+        queryName: String(queryDefinition?.name || queryId),
+        asOf,
+        total: 0,
+        rows: [],
+        snapshotMap: new Map<number, HistoricalWorkItemSnapshot>(),
+      };
+    }
+
+    const values = await this.fetchHistoricalWorkItemsBatch(project, ids, asOf, apiVersion);
+    const rows = values
+      .map((workItem: any) => this.toHistoricalWorkItemSnapshot(project, workItem))
+      .sort((a: HistoricalWorkItemSnapshot, b: HistoricalWorkItemSnapshot) => a.id - b.id);
+    const snapshotMap = new Map<number, HistoricalWorkItemSnapshot>();
+    for (const row of rows) {
+      snapshotMap.set(row.id, row);
+    }
+
+    return {
+      queryId,
+      queryName: String(queryDefinition?.name || queryId),
+      asOf,
+      total: rows.length,
+      rows,
+      snapshotMap,
+    };
+  }
+
+  private collectHistoricalQueries(root: any, parentPath = ''): HistoricalQueryListItem[] {
+    const items: HistoricalQueryListItem[] = [];
+    if (!root) {
+      return items;
+    }
+
+    const name = String(root?.name || '').trim();
+    const currentPath = parentPath && name ? `${parentPath}/${name}` : name || parentPath;
+
+    if (!root?.isFolder) {
+      const id = String(root?.id || '').trim();
+      if (id) {
+        items.push({
+          id,
+          queryName: name || id,
+          path: parentPath || 'Shared Queries',
+        });
+      }
+      return items;
+    }
+
+    const children = Array.isArray(root?.children) ? root.children : [];
+    for (const child of children) {
+      items.push(...this.collectHistoricalQueries(child, currentPath || 'Shared Queries'));
+    }
+    return items;
+  }
+
+  /**
+   * Returns a flat list of shared queries for historical/as-of execution.
+   */
+  async GetHistoricalQueries(project: string, path: string = 'shared'): Promise<HistoricalQueryListItem[]> {
+    const normalizedPath = this.normalizeHistoricalQueryPath(path);
+    // Azure DevOps WIT query tree endpoint enforces $depth range 0..2.
+    const depth = 2;
+    const { result: root } = await this.withHistoricalApiVersionFallback('historical-queries-list', (apiVersion) => {
+      const url = this.appendApiVersion(
+        `${this.orgUrl}${project}/_apis/wit/queries/${normalizedPath}?$depth=${depth}&$expand=all`,
+        apiVersion,
+      );
+      return TFSServices.getItemContent(url, this.token);
+    });
+    const normalizedRoot = this.normalizeHistoricalQueryRoot(root);
+    const items = this.collectHistoricalQueries(normalizedRoot).filter((query) => query.id !== '');
+    items.sort((a, b) => {
+      const byPath = a.path.localeCompare(b.path);
+      if (byPath !== 0) return byPath;
+      return a.queryName.localeCompare(b.queryName);
+    });
+    return items;
+  }
+
+  /**
+   * Runs a shared query as-of a specific date-time and returns a flat work-item table snapshot.
+   */
+  async GetHistoricalQueryResults(queryId: string, project: string, asOfInput: string): Promise<any> {
+    const snapshot = await this.getHistoricalSnapshot(project, queryId, asOfInput);
+    return {
+      queryId: snapshot.queryId,
+      queryName: snapshot.queryName,
+      asOf: snapshot.asOf,
+      total: snapshot.total,
+      rows: snapshot.rows.map((row) => ({
+        id: row.id,
+        workItemType: row.workItemType,
+        title: row.title,
+        state: row.state,
+        areaPath: row.areaPath,
+        iterationPath: row.iterationPath,
+        versionId: row.versionId,
+        versionTimestamp: row.versionTimestamp,
+        workItemUrl: row.workItemUrl,
+      })),
+    };
+  }
+
+  /**
+   * Compares a shared query between two date-time baselines using the feature's noise-control fields.
+   */
+  async CompareHistoricalQueryResults(
+    queryId: string,
+    project: string,
+    baselineAsOfInput: string,
+    compareToAsOfInput: string,
+  ): Promise<any> {
+    const [baseline, compareTo] = await Promise.all([
+      this.getHistoricalSnapshot(project, queryId, baselineAsOfInput),
+      this.getHistoricalSnapshot(project, queryId, compareToAsOfInput),
+    ]);
+
+    const allIds = new Set<number>([
+      ...Array.from(baseline.snapshotMap.keys()),
+      ...Array.from(compareTo.snapshotMap.keys()),
+    ]);
+    const sortedIds = Array.from(allIds.values()).sort((a, b) => a - b);
+
+    const rows = sortedIds.map((id) => {
+      const baselineRow = baseline.snapshotMap.get(id) || null;
+      const compareToRow = compareTo.snapshotMap.get(id) || null;
+      const workItemType = compareToRow?.workItemType || baselineRow?.workItemType || '';
+      const isTestCase = this.isTestCaseType(workItemType);
+
+      if (baselineRow && !compareToRow) {
+        return {
+          id,
+          workItemType,
+          title: baselineRow.title,
+          baselineRevisionId: baselineRow.versionId,
+          compareToRevisionId: null,
+          compareStatus: 'Deleted',
+          changedFields: [],
+          differences: [],
+          workItemUrl: baselineRow.workItemUrl,
+        };
+      }
+
+      if (!baselineRow && compareToRow) {
+        return {
+          id,
+          workItemType,
+          title: compareToRow.title,
+          baselineRevisionId: null,
+          compareToRevisionId: compareToRow.versionId,
+          compareStatus: 'Added',
+          changedFields: [],
+          differences: [],
+          workItemUrl: compareToRow.workItemUrl,
+        };
+      }
+
+      const safeBaseline = baselineRow as HistoricalWorkItemSnapshot;
+      const safeCompareTo = compareToRow as HistoricalWorkItemSnapshot;
+      const changedFields: string[] = [];
+
+      if (safeBaseline.description !== safeCompareTo.description) {
+        changedFields.push('Description');
+      }
+      if (safeBaseline.title !== safeCompareTo.title) {
+        changedFields.push('Title');
+      }
+      if (safeBaseline.state !== safeCompareTo.state) {
+        changedFields.push('State');
+      }
+      if (isTestCase && safeBaseline.steps !== safeCompareTo.steps) {
+        changedFields.push('Steps');
+      }
+      if (safeBaseline.testPhase !== safeCompareTo.testPhase) {
+        changedFields.push('Test Phase');
+      }
+      if (isTestCase && safeBaseline.relatedLinkCount !== safeCompareTo.relatedLinkCount) {
+        changedFields.push('Related Link Count');
+      }
+
+      const differences = changedFields.map((field) => {
+        switch (field) {
+          case 'Description':
+            return { field, baseline: safeBaseline.description, compareTo: safeCompareTo.description };
+          case 'Title':
+            return { field, baseline: safeBaseline.title, compareTo: safeCompareTo.title };
+          case 'State':
+            return { field, baseline: safeBaseline.state, compareTo: safeCompareTo.state };
+          case 'Steps':
+            return { field, baseline: safeBaseline.steps, compareTo: safeCompareTo.steps };
+          case 'Test Phase':
+            return { field, baseline: safeBaseline.testPhase, compareTo: safeCompareTo.testPhase };
+          case 'Related Link Count':
+            return {
+              field,
+              baseline: String(safeBaseline.relatedLinkCount),
+              compareTo: String(safeCompareTo.relatedLinkCount),
+            };
+          default:
+            return { field, baseline: '', compareTo: '' };
+        }
+      });
+
+      return {
+        id,
+        workItemType,
+        title: safeCompareTo.title || safeBaseline.title,
+        baselineRevisionId: safeBaseline.versionId,
+        compareToRevisionId: safeCompareTo.versionId,
+        compareStatus: changedFields.length > 0 ? 'Changed' : 'No changes',
+        changedFields,
+        differences,
+        workItemUrl: safeCompareTo.workItemUrl || safeBaseline.workItemUrl,
+      };
+    });
+
+    const summary = rows.reduce(
+      (acc, row) => {
+        if (row.compareStatus === 'Added') acc.addedCount += 1;
+        else if (row.compareStatus === 'Deleted') acc.deletedCount += 1;
+        else if (row.compareStatus === 'Changed') acc.changedCount += 1;
+        else acc.noChangeCount += 1;
+        return acc;
+      },
+      { addedCount: 0, deletedCount: 0, changedCount: 0, noChangeCount: 0 },
+    );
+
+    return {
+      queryId,
+      queryName: compareTo.queryName || baseline.queryName || queryId,
+      baseline: {
+        asOf: baseline.asOf,
+        total: baseline.total,
+      },
+      compareTo: {
+        asOf: compareTo.asOf,
+        total: compareTo.total,
+      },
+      summary: {
+        ...summary,
+        updatedCount: summary.changedCount,
+      },
+      rows,
+    };
+  }
+
   async PopulateWorkItemsByIds(workItemsArray: any[] = [], projectName: string = ''): Promise<any[]> {
     let url = `${this.orgUrl}${projectName}/_apis/wit/workitemsbatch`;
     let res: any[] = [];
@@ -1585,7 +2288,7 @@ export default class TicketsDataProvider {
 
   async CreateNewWorkItem(projectName: string, wiBody: any, wiType: string, byPass: boolean) {
     let url = `${this.orgUrl}${projectName}/_apis/wit/workitems/$${wiType}?bypassRules=${String(
-      byPass
+      byPass,
     ).toString()}`;
     return TFSServices.getItemContent(url, this.token, 'POST', wiBody, {
       'Content-Type': 'application/json-patch+json',
@@ -1605,7 +2308,7 @@ export default class TicketsDataProvider {
             attachment.downloadUrl = `${relation.url}/${relation.attributes.name}`;
             attachmentList.push(attachment);
           }
-        })
+        }),
       );
       return attachmentList;
     } catch (e) {
@@ -1626,7 +2329,7 @@ export default class TicketsDataProvider {
   async UpdateWorkItem(projectName: string, wiBody: any, workItemId: number, byPass: boolean) {
     let res: any;
     let url: string = `${this.orgUrl}${projectName}/_apis/wit/workitems/${workItemId}?bypassRules=${String(
-      byPass
+      byPass,
     ).toString()}`;
     res = await TFSServices.getItemContent(url, this.token, 'patch', wiBody, {
       'Content-Type': 'application/json-patch+json',
@@ -1680,7 +2383,7 @@ export default class TicketsDataProvider {
 
       // Process children recursively
       const childResults = await Promise.all(
-        rootQuery.children.map((child: any) => this.structureAllQueryPath(child, rootQuery.id))
+        rootQuery.children.map((child: any) => this.structureAllQueryPath(child, rootQuery.id)),
       );
 
       // Build tree
@@ -1718,8 +2421,8 @@ export default class TicketsDataProvider {
     } catch (err: any) {
       logger.error(
         `Error occurred while constructing the query list ${err.message} with query ${JSON.stringify(
-          rootQuery
-        )}`
+          rootQuery,
+        )}`,
       );
       throw err;
     }
@@ -1757,7 +2460,7 @@ export default class TicketsDataProvider {
     includeTreeQueries: boolean = false,
     excludedFolderNames: string[] = [],
     includeFlatQueries: boolean = false,
-    workItemTypeCache?: Map<string, string | null>
+    workItemTypeCache?: Map<string, string | null>,
   ): Promise<any> {
     try {
       // Per-invocation cache for ID->WorkItemType lookups; avoids global state and is safe for concurrency.
@@ -1765,7 +2468,7 @@ export default class TicketsDataProvider {
       const shouldSkipFolder =
         rootQuery?.isFolder &&
         excludedFolderNames.some(
-          (folderName) => folderName.toLowerCase() === (rootQuery.name || '').toLowerCase()
+          (folderName) => folderName.toLowerCase() === (rootQuery.name || '').toLowerCase(),
         );
 
       if (shouldSkipFolder) {
@@ -1789,7 +2492,7 @@ export default class TicketsDataProvider {
               rootQuery,
               wiql,
               allTypes,
-              typeCache
+              typeCache,
             );
 
             if (typesOk) {
@@ -1816,7 +2519,7 @@ export default class TicketsDataProvider {
                 wiql,
                 sources,
                 targets,
-                typeCache
+                typeCache,
               );
             }
             const matchesReverse = await this.matchesSourceTargetConditionAsync(
@@ -1824,7 +2527,7 @@ export default class TicketsDataProvider {
               wiql,
               targets,
               sources,
-              typeCache
+              typeCache,
             );
 
             if (matchesForward) {
@@ -1871,7 +2574,7 @@ export default class TicketsDataProvider {
           includeTreeQueries,
           excludedFolderNames,
           includeFlatQueries,
-          typeCache
+          typeCache,
         );
       }
 
@@ -1889,9 +2592,9 @@ export default class TicketsDataProvider {
             includeTreeQueries,
             excludedFolderNames,
             includeFlatQueries,
-            typeCache
-          )
-        )
+            typeCache,
+          ),
+        ),
       );
 
       // Build tree1
@@ -1924,8 +2627,8 @@ export default class TicketsDataProvider {
     } catch (err: any) {
       logger.error(
         `Error occurred while constructing the query list ${err.message} with query ${JSON.stringify(
-          rootQuery
-        )}`
+          rootQuery,
+        )}`,
       );
       logger.error(`Error stack ${err.message}`);
     }
@@ -1941,7 +2644,7 @@ export default class TicketsDataProvider {
   private matchesAreaPathCondition(
     wiql: string,
     sourceAreaFilter: string,
-    targetAreaFilter: string
+    targetAreaFilter: string,
   ): boolean {
     const wiqlLower = (wiql || '').toLowerCase();
     const srcFilter = (sourceAreaFilter || '').toLowerCase().trim();
@@ -1979,7 +2682,7 @@ export default class TicketsDataProvider {
     wiql: string,
     source: string[],
     target: string[],
-    workItemTypeCache: Map<string, string | null>
+    workItemTypeCache: Map<string, string | null>,
   ): Promise<boolean> {
     /**
      * Matches source+target constraints for link WIQL.
@@ -1992,7 +2695,7 @@ export default class TicketsDataProvider {
       wiql,
       'Source',
       source,
-      workItemTypeCache
+      workItemTypeCache,
     );
     if (!sourceOk) return false;
     const targetOk = await this.isLinkSideAllowedByTypeOrId(
@@ -2000,7 +2703,7 @@ export default class TicketsDataProvider {
       wiql,
       'Target',
       target,
-      workItemTypeCache
+      workItemTypeCache,
     );
     return targetOk;
   }
@@ -2009,7 +2712,7 @@ export default class TicketsDataProvider {
     queryNode: any,
     wiql: string,
     allowedTypes: string[],
-    workItemTypeCache: Map<string, string | null>
+    workItemTypeCache: Map<string, string | null>,
   ): Promise<boolean> {
     return this.isFlatQueryAllowedByTypeOrId(queryNode, wiql, allowedTypes, workItemTypeCache);
   }
@@ -2149,7 +2852,7 @@ export default class TicketsDataProvider {
     wiql: string,
     context: 'Source' | 'Target',
     allowedTypes: string[],
-    workItemTypeCache: Map<string, string | null>
+    workItemTypeCache: Map<string, string | null>,
   ): Promise<boolean> {
     const wiqlStr = String(wiql || '');
 
@@ -2157,7 +2860,7 @@ export default class TicketsDataProvider {
     if (!allowedTypes || allowedTypes.length === 0) {
       const fieldPresenceRegex = new RegExp(
         `${this.buildWiqlFieldPattern(context, 'System.WorkItemType')}`,
-        'i'
+        'i',
       );
       return fieldPresenceRegex.test(wiqlStr);
     }
@@ -2197,7 +2900,7 @@ export default class TicketsDataProvider {
     queryNode: any,
     wiql: string,
     allowedTypes: string[],
-    workItemTypeCache: Map<string, string | null>
+    workItemTypeCache: Map<string, string | null>,
   ): Promise<boolean> {
     const wiqlStr = String(wiql || '');
 
@@ -2240,7 +2943,7 @@ export default class TicketsDataProvider {
   private async getWorkItemTypeById(
     project: string,
     id: string,
-    workItemTypeCache: Map<string, string | null>
+    workItemTypeCache: Map<string, string | null>,
   ): Promise<string | null> {
     const cacheKey = `${project}:${id}`;
     if (workItemTypeCache.has(cacheKey)) {
@@ -2298,7 +3001,7 @@ export default class TicketsDataProvider {
   private filterFieldsByColumns(
     item: any,
     columnsToFilterMap: Map<string, string>,
-    resultedRefNameMap: Map<string, string>
+    resultedRefNameMap: Map<string, string>,
   ) {
     try {
       const parsedFields: any = {};
@@ -2345,14 +3048,14 @@ export default class TicketsDataProvider {
                   this.token,
                   'get',
                   {},
-                  { Accept: accept }
+                  { Accept: accept },
                 );
                 if (iconDataUrl) break;
               } catch (error: any) {
                 logger.warn(
                   `Failed to download icon (${accept}) for work item type ${
                     workItemType?.name ?? 'unknown'
-                  }: ${error?.message || error}`
+                  }: ${error?.message || error}`,
                 );
               }
             }
@@ -2361,8 +3064,8 @@ export default class TicketsDataProvider {
           const iconPayload = workItemType.icon
             ? { ...workItemType.icon, dataUrl: iconDataUrl }
             : iconDataUrl
-            ? { id: undefined, url: undefined, dataUrl: iconDataUrl }
-            : workItemType.icon;
+              ? { id: undefined, url: undefined, dataUrl: iconDataUrl }
+              : workItemType.icon;
 
           return {
             name: workItemType.name,
@@ -2371,7 +3074,7 @@ export default class TicketsDataProvider {
             icon: iconPayload,
             states: workItemType.states,
           };
-        })
+        }),
       );
 
       return workItemTypesWithIcons;
@@ -2543,7 +3246,7 @@ export default class TicketsDataProvider {
       });
 
       logger.debug(
-        `Categorized ${workItemIds.length} work items into ${Object.keys(finalCategories).length} categories`
+        `Categorized ${workItemIds.length} work items into ${Object.keys(finalCategories).length} categories`,
       );
 
       return {