create-appraisejs 0.2.0 → 0.3.0-alpha.1

package/templates/default/src/lib/sync/sync-pending-counts.ts

@@ -1,1359 +0,0 @@
-import { promises as fs } from 'fs'
-import { join } from 'path'
-import { glob } from 'glob'
-import prettier from 'prettier'
-import { parse } from '@babel/parser'
-import * as t from '@babel/types'
-import _traverse from '@babel/traverse'
-import type { NodePath } from '@babel/traverse'
-import {
-  StepParameterType,
-  TagType,
-  TemplateStepGroupType,
-  TemplateStepIcon,
-  TemplateStepType,
-} from '@prisma/client'
-import prisma from '@/config/db-config'
-import {
-  ensureAutomationWorkspaceReady,
-  getAutomationEnvironmentsDir,
-  getAutomationFeaturesDir,
-} from '@/lib/automation/paths'
-import { extractModulePathFromFilePath, scanFeatureFiles, type ParsedFeature, type ParsedStep } from '@/lib/gherkin-parser'
-import { getAllModulesWithPaths } from '@/lib/module-hierarchy-builder'
-import { SYNC_ALL_REQUEST_ID, syncScriptDefinitions, type SyncRequestId, type SyncScriptId } from '@/lib/sync/sync-registry'
-import { getTagTypeFromName } from '@/lib/tag-utils'
-import { extractModulePathFromAutomationFile, getAutomationLocatorMapPath } from '@/lib/template-sync-utils'
-import {
-  determineProjectedStepIcon,
-  getTestSuiteSyncIdentity,
-  normalizeProjectedDbTestCaseSteps,
-} from '@/lib/sync/projected-feature-utils'
-
-const traverse = (_traverse as { default?: typeof _traverse }).default ?? _traverse
-
-export type SyncPendingCounts = Record<SyncRequestId, number>
-
-type EnvironmentConfig = {
-  baseUrl: string
-  apiBaseUrl: string
-  email: string
-  password: string
-}
-
-type EnvironmentData = {
-  name: string
-  baseUrl: string
-  apiBaseUrl: string | null
-  username: string | null
-  password: string | null
-}
-
-type LocatorMapEntry = {
-  name: string
-  path: string
-}
-
-type LocatorGroupFromFs = {
-  name: string
-  route: string
-  modulePath: string
-}
-
-type LocatorFileData = {
-  groupName: string
-  modulePath: string
-  locators: Record<string, string>
-}
-
-type StepGroupJSDoc = {
-  name: string
-  description: string | null
-  type: TemplateStepGroupType
-}
-
-type StepJSDoc = {
-  name: string
-  description: string | null
-  icon: TemplateStepIcon
-}
-
-type StepParameter = {
-  name: string
-  type: StepParameterType
-  order: number
-}
-
-type ParsedTemplateStep = {
-  jsdoc: StepJSDoc
-  signature: string
-  functionDefinition: string
-  normalizedFunctionDefinition: string
-  parameters: StepParameter[]
-  keyword: 'When' | 'Then' | 'Given'
-}
-
-type ParsedStepFile = {
-  group: StepGroupJSDoc
-  steps: ParsedTemplateStep[]
-}
-
-type TemplateStepFromFs = {
-  step: ParsedTemplateStep
-  groupName: string
-  groupType: TemplateStepGroupType
-}
-
-type TestSuiteFromFs = {
-  name: string
-  description: string | null
-  modulePath: string
-  tags: string[]
-}
-
-type TestCaseFromFs = {
-  identifierTag: string
-  title: string
-  description: string
-  testSuiteName: string
-  modulePath: string
-  filterTags: string[]
-  steps: ParsedStep[]
-}
-
-type ParameterMatch = {
-  name: string
-  value: string
-  order: number
-  type: StepParameterType
-}
-
-type FilesystemSnapshot = {
-  environments: EnvironmentData[]
-  modulePaths: Set<string>
-  locatorGroups: LocatorGroupFromFs[]
-  locatorFiles: LocatorFileData[]
-  tagObjects: Array<{ name: string; tagExpression: string; type: TagType }>
-  templateStepGroups: StepGroupJSDoc[]
-  templateSteps: TemplateStepFromFs[]
-  testSuites: TestSuiteFromFs[]
-  testCases: TestCaseFromFs[]
-}
-
-function normalizeEnvironmentName(name: string): string {
-  if (!name || name.trim() === '') {
-    return name
-  }
-
-  return name
-    .trim()
-    .replace(/[_\s]+/g, ' ')
-    .split(' ')
-    .filter(Boolean)
-    .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase())
-    .join(' ')
-}
-
-function getEnvironmentIdentityKey(name: string): string {
-  return name
-    .trim()
-    .replace(/[_\s]+/g, ' ')
-    .toLowerCase()
-}
-
-async function normalizeFunctionDefinition(functionDefinition: string | null | undefined): Promise<string> {
-  const source = functionDefinition?.trim()
-  if (!source) {
-    return ''
-  }
-
-  try {
-    return (
-      await prettier.format(source, {
-        parser: 'typescript',
-        semi: true,
-        singleQuote: true,
-        trailingComma: 'es5',
-        printWidth: 80,
-        tabWidth: 2,
-      })
-    ).trim()
-  } catch {
-    return source
-  }
-}
-
-async function readEnvironmentsFromFile(): Promise<EnvironmentData[]> {
-  const filePath = join(getAutomationEnvironmentsDir(), 'environments.json')
-
-  try {
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    const jsonContent = JSON.parse(fileContent) as Record<string, EnvironmentConfig>
-
-    return Object.entries(jsonContent).map(([key, config]) => ({
-      name: normalizeEnvironmentName(key),
-      baseUrl: config.baseUrl.trim(),
-      apiBaseUrl: config.apiBaseUrl?.trim() ? config.apiBaseUrl.trim() : null,
-      username: config.email?.trim() ? config.email.trim() : null,
-      password: config.password?.trim() ? config.password.trim() : null,
-    }))
-  } catch (error) {
-    console.error('Unable to read environments for sync counts:', error)
-    return []
-  }
-}
-
-function splitTagLine(tagLine: string): string[] {
-  return tagLine
-    .split(/\s+/)
-    .filter(tag => tag.trim().startsWith('@'))
-    .map(tag => tag.trim())
-}
-
-function normalizeTagExpression(tagExpression: string): string {
-  return tagExpression.startsWith('@') ? tagExpression : `@${tagExpression}`
-}
-
-function extractUniqueTags(parsedFeatures: ParsedFeature[]): Set<string> {
-  const uniqueTags = new Set<string>()
-
-  for (const feature of parsedFeatures) {
-    for (const tagLine of feature.tags) {
-      for (const tag of splitTagLine(tagLine)) {
-        uniqueTags.add(tag)
-      }
-    }
-
-    for (const scenario of feature.scenarios) {
-      for (const tagLine of scenario.tags) {
-        for (const tag of splitTagLine(tagLine)) {
-          uniqueTags.add(tag)
-        }
-      }
-    }
-  }
-
-  return uniqueTags
-}
-
-function buildTagObjects(tagExpressions: Set<string>): Array<{ name: string; tagExpression: string; type: TagType }> {
-  return Array.from(tagExpressions).map(tagExpression => {
-    const name = tagExpression.startsWith('@') ? tagExpression.substring(1) : tagExpression
-    return {
-      name,
-      tagExpression,
-      type: getTagTypeFromName(name),
-    }
-  })
-}
-
-function buildModuleTreePaths(modulePaths: Iterable<string>): Set<string> {
-  const tree = new Set<string>()
-
-  for (const modulePath of modulePaths) {
-    if (modulePath === '/') {
-      tree.add('/')
-      continue
-    }
-
-    const parts = modulePath.split('/').filter(Boolean)
-    let currentPath = ''
-
-    for (const part of parts) {
-      currentPath += `/${part}`
-      tree.add(currentPath)
-    }
-  }
-
-  return tree
-}
-
-async function scanLocatorFiles(baseDir: string): Promise<string[]> {
-  const files = await glob('automation/locators/**/*.json', { cwd: baseDir })
-  return files.map(file => join(baseDir, file))
-}
-
-async function readLocatorMap(baseDir: string): Promise<LocatorMapEntry[]> {
-  try {
-    const fileContent = await fs.readFile(getAutomationLocatorMapPath(baseDir), 'utf-8')
-    const locatorMap = JSON.parse(fileContent) as LocatorMapEntry[]
-    return Array.isArray(locatorMap) ? locatorMap : []
-  } catch {
-    return []
-  }
-}
-
-function extractLocatorGroupName(filePath: string): string {
-  const fileName = filePath.split(/[/\\]/).pop() ?? ''
-  return fileName.replace(/\.json$/, '')
-}
-
-async function readLocatorFile(filePath: string): Promise<Record<string, string>> {
-  try {
-    const fileContent = await fs.readFile(filePath, 'utf-8')
-    const content = JSON.parse(fileContent) as Record<string, string>
-    return typeof content === 'object' && content !== null ? content : {}
-  } catch (error) {
-    console.error(`Unable to read locator file ${filePath}:`, error)
-    return {}
-  }
-}
-
-function parseGroupJSDoc(content: string): StepGroupJSDoc | null {
-  const lines = content.split('\n')
-  let startLine = 0
-
-  while (startLine < lines.length) {
-    const line = lines[startLine].trim()
-    if (line === '' || line.startsWith('import ')) {
-      startLine++
-      continue
-    }
-    break
-  }
-
-  if (startLine >= lines.length || !lines[startLine].trim().startsWith('/**')) {
-    return null
-  }
-
-  let hasType = false
-  let endLine = -1
-  let name: string | null = null
-  let description: string | null = null
-  let type: string | null = null
-
-  const maxLines = Math.min(lines.length, startLine + 50)
-  for (let i = startLine; i < maxLines; i++) {
-    const line = lines[i].trim()
-
-    if (line.includes('*/')) {
-      const beforeClose = line.split('*/')[0].trim()
-
-      if (beforeClose.startsWith('* @name') || beforeClose.startsWith('*@name')) {
-        const match = beforeClose.match(/@name\s+(.+)/)
-        if (match) name = match[1].trim()
-      } else if (beforeClose.startsWith('* @description') || beforeClose.startsWith('*@description')) {
-        const match = beforeClose.match(/@description\s+(.+)/)
-        if (match) description = match[1].trim() || null
-      } else if (beforeClose.startsWith('* @type') || beforeClose.startsWith('*@type')) {
-        const match = beforeClose.match(/@type\s+(.+)/)
-        if (match) {
-          hasType = true
-          type = match[1].trim()
-        }
-      }
-
-      endLine = i
-      break
-    }
-
-    if (line.startsWith('* @name') || line.startsWith('*@name')) {
-      const match = line.match(/@name\s+(.+)/)
-      if (match) name = match[1].trim()
-    } else if (line.startsWith('* @description') || line.startsWith('*@description')) {
-      const match = line.match(/@description\s+(.+)/)
-      if (match) description = match[1].trim() || null
-    } else if (line.startsWith('* @type') || line.startsWith('*@type')) {
-      const match = line.match(/@type\s+(.+)/)
-      if (match) {
-        hasType = true
-        type = match[1].trim()
-      }
-    }
-  }
-
-  if (!hasType || endLine < 0 || !name || !type) {
-    return null
-  }
-
-  const normalizedType = type.toUpperCase()
-  if (normalizedType !== 'ACTION' && normalizedType !== 'VALIDATION') {
-    return null
-  }
-
-  return {
-    name: name.trim(),
-    description: description ? description.trim() : null,
-    type: normalizedType as TemplateStepGroupType,
-  }
-}
-
-function parseStepJSDoc(content: string, startLine: number): StepJSDoc | null {
-  const lines = content.split('\n')
-  let jsdocStart = -1
-
-  for (let i = startLine - 1; i >= 0 && i >= startLine - 20; i--) {
-    const line = lines[i]?.trim()
-    if (line?.includes('*/')) {
-      jsdocStart = i
-      for (let j = i - 1; j >= 0 && j >= i - 10; j--) {
-        const previousLine = lines[j]?.trim()
-        if (previousLine?.startsWith('/**')) {
-          jsdocStart = j
-          break
-        }
-      }
-      break
-    }
-
-    if (line?.startsWith('/**')) {
-      jsdocStart = i
-      break
-    }
-  }
-
-  if (jsdocStart === -1) {
-    return null
-  }
-
-  let name: string | null = null
-  let description: string | null = null
-  let icon: string | null = null
-  let foundJSDoc = false
-
-  for (let i = jsdocStart; i < Math.min(lines.length, jsdocStart + 20); i++) {
-    const line = lines[i]?.trim()
-
-    if (line?.startsWith('/**')) {
-      foundJSDoc = true
-      continue
-    }
-
-    if (line?.includes('*/')) {
-      const beforeClose = line.split('*/')[0].trim()
-      if (beforeClose.startsWith('* @name') || beforeClose.startsWith('*@name')) {
-        const match = beforeClose.match(/@name\s+(.+)/)
-        if (match) name = match[1].trim()
-      } else if (beforeClose.startsWith('* @description') || beforeClose.startsWith('*@description')) {
-        const match = beforeClose.match(/@description\s+(.+)/)
-        if (match) description = match[1].trim() || null
-      } else if (beforeClose.startsWith('* @icon') || beforeClose.startsWith('*@icon')) {
-        const match = beforeClose.match(/@icon\s+(.+)/)
-        if (match) icon = match[1].trim()
-      }
-      break
-    }
-
-    if (!foundJSDoc) {
-      continue
-    }
-
-    if (line?.startsWith('* @name') || line?.startsWith('*@name')) {
-      const match = line.match(/@name\s+(.+)/)
-      if (match) name = match[1].trim()
-    } else if (line?.startsWith('* @description') || line?.startsWith('*@description')) {
-      const match = line.match(/@description\s+(.+)/)
-      if (match) description = match[1].trim() || null
-    } else if (line?.startsWith('* @icon') || line?.startsWith('*@icon')) {
-      const match = line.match(/@icon\s+(.+)/)
-      if (match) icon = match[1].trim()
-    }
-  }
-
-  if (!name || !icon) {
-    return null
-  }
-
-  const iconUpper = icon.toUpperCase()
-  const validIcons = Object.values(TemplateStepIcon)
-  if (!validIcons.includes(iconUpper as TemplateStepIcon)) {
-    return null
-  }
-
-  return {
-    name: name.trim(),
-    description: description ? description.trim() : null,
-    icon: iconUpper as TemplateStepIcon,
-  }
-}
-
-function mapTypeToParameterType(typeName: string): StepParameterType {
-  const normalized = typeName.trim()
-
-  if (normalized === 'SelectorName') return StepParameterType.LOCATOR
-  if (normalized === 'string') return StepParameterType.STRING
-  if (normalized === 'number' || normalized === 'int') return StepParameterType.NUMBER
-  if (normalized === 'boolean') return StepParameterType.BOOLEAN
-  if (normalized === 'Date') return StepParameterType.DATE
-
-  throw new Error(`Unsupported parameter type: ${typeName}`)
-}
-
-function extractFunctionDefinition(callExpression: t.CallExpression, sourceCode: string): string {
-  const start = callExpression.start
-  const end = callExpression.end
-
-  if (start == null || end == null) {
-    throw new Error('Cannot extract function definition.')
-  }
-
-  let code = sourceCode.slice(start, end).trim()
-  const trailingSource = sourceCode.slice(end, end + 10).trim()
-  if (trailingSource.startsWith(';')) {
-    code += ';'
-  }
-
-  return code
-}
-
-function parseStepFile(content: string): ParsedStepFile | null {
-  const group = parseGroupJSDoc(content)
-  if (!group) {
-    return null
-  }
-
-  const ast = parse(content, {
-    sourceType: 'module',
-    plugins: ['typescript', 'decorators-legacy'],
-  })
-
-  const steps: ParsedTemplateStep[] = []
-
-  traverse(ast, {
-    CallExpression(path: NodePath<t.CallExpression>) {
-      const node = path.node
-      const callee = node.callee
-      let keyword: 'When' | 'Then' | 'Given' | null = null
-
-      if (t.isIdentifier(callee) && (callee.name === 'When' || callee.name === 'Then' || callee.name === 'Given')) {
-        keyword = callee.name as 'When' | 'Then' | 'Given'
-      }
-
-      if (!keyword || node.arguments.length < 2) {
-        return
-      }
-
-      const patternArg = node.arguments[0]
-      const functionArg = node.arguments[1]
-
-      if (!t.isStringLiteral(patternArg) || !t.isFunction(functionArg)) {
-        return
-      }
-
-      const lineNumber = node.loc?.start?.line
-      if (lineNumber == null) {
-        return
-      }
-
-      const jsdoc = parseStepJSDoc(content, lineNumber - 1)
-      if (!jsdoc) {
-        return
-      }
-
-      const parameters: StepParameter[] = []
-      let order = 0
-
-      for (const parameter of functionArg.params) {
-        if (t.isIdentifier(parameter) && parameter.name === 'this') {
-          continue
-        }
-
-        if (t.isObjectPattern(parameter)) {
-          continue
-        }
-
-        if (!t.isIdentifier(parameter) || !parameter.typeAnnotation || !t.isTSTypeAnnotation(parameter.typeAnnotation)) {
-          continue
-        }
-
-        const annotation = parameter.typeAnnotation.typeAnnotation
-        let typeName: string | null = null
-
-        if (t.isTSTypeReference(annotation) && t.isIdentifier(annotation.typeName)) {
-          typeName = annotation.typeName.name
-        } else if (t.isTSStringKeyword(annotation)) {
-          typeName = 'string'
-        } else if (t.isTSNumberKeyword(annotation)) {
-          typeName = 'number'
-        } else if (t.isTSBooleanKeyword(annotation)) {
-          typeName = 'boolean'
-        }
-
-        if (!typeName) {
-          continue
-        }
-
-        try {
-          parameters.push({
-            name: parameter.name,
-            type: mapTypeToParameterType(typeName),
-            order: order++,
-          })
-        } catch {
-          return
-        }
-      }
-
-      steps.push({
-        jsdoc,
-        signature: patternArg.value,
-        functionDefinition: extractFunctionDefinition(node, content),
-        normalizedFunctionDefinition: '',
-        parameters,
-        keyword,
-      })
-    },
-  })
-
-  return { group, steps }
-}
-
-async function scanStepFiles(baseDir: string): Promise<string[]> {
-  const actionFiles = await glob('automation/steps/actions/**/*.step.ts', { cwd: baseDir })
-  const validationFiles = await glob('automation/steps/validations/**/*.step.ts', { cwd: baseDir })
-  return [...actionFiles, ...validationFiles]
-}
-
-function extractTestSuiteNameFromFilename(filePath: string): string {
-  const fileName = filePath.split(/[/\\]/).pop() ?? ''
-  return fileName.replace(/\.feature$/, '')
-}
-
-function extractFeatureLevelTags(parsedFeature: ParsedFeature): string[] {
-  return parsedFeature.tags.flatMap(splitTagLine)
-}
-
-function parseScenarioTitle(scenarioName: string, scenarioDescription?: string): { title: string; description: string } {
-  if (scenarioDescription) {
-    return {
-      title: scenarioDescription.trim(),
-      description: scenarioName.trim(),
-    }
-  }
-
-  return {
-    title: scenarioName.trim(),
-    description: '',
-  }
-}
-
-function signatureToRegex(signature: string): RegExp {
-  let pattern = signature.replace(/[.*+?^${}()|[\]\\]/g, match => {
-    if (match === '{' || match === '}') return match
-    return `\\${match}`
-  })
-
-  pattern = pattern.replace(/\{string\}/g, '"([^"]+)"')
-  pattern = pattern.replace(/\{int\}/g, '(\\d+)')
-  pattern = pattern.replace(/\{boolean\}/g, '(true|false)')
-  pattern = pattern.replace(/\{number\}/g, '(\\d+(?:\\.\\d+)?)')
-
-  return new RegExp(`^${pattern}$`, 'i')
-}
-
-function extractParametersFromGherkinStep(
-  gherkinText: string,
-  signature: string,
-  templateStepParameters: Array<{ name: string; order: number; type: StepParameterType }>,
-): ParameterMatch[] | null {
-  const match = gherkinText.match(signatureToRegex(signature))
-  if (!match) {
-    return null
-  }
-
-  return match.slice(1).flatMap((value, index) => {
-    const parameter = templateStepParameters[index]
-    if (!parameter || value == null) {
-      return []
-    }
-
-    return [
-      {
-        name: parameter.name,
-        value,
-        order: parameter.order,
-        type: parameter.type,
-      },
-    ]
-  })
-}
-
-function matchGherkinStepToTemplateStep(
-  gherkinStep: ParsedStep,
-  templateSteps: Array<{
-    signature: string
-    parameters: Array<{ name: string; order: number; type: StepParameterType }>
-  }>,
-): { signature: string; parameters: ParameterMatch[] } | null {
-  for (const templateStep of templateSteps) {
-    const parameters = extractParametersFromGherkinStep(gherkinStep.text, templateStep.signature, templateStep.parameters)
-    if (parameters) {
-      return {
-        signature: templateStep.signature,
-        parameters,
-      }
-    }
-  }
-
-  return null
-}
-
-function groupRecordsByKey<T>(records: T[], getKey: (record: T) => string | null | undefined): Map<string, T[]> {
-  const recordsByKey = new Map<string, T[]>()
-
-  for (const record of records) {
-    const key = getKey(record)
-    if (!key) {
-      continue
-    }
-
-    const existing = recordsByKey.get(key)
-    if (existing) {
-      existing.push(record)
-      continue
-    }
-
-    recordsByKey.set(key, [record])
-  }
-
-  return recordsByKey
-}
-
-function sameStringSet(left: string[], right: string[]): boolean {
-  const sortedLeft = [...left].sort()
-  const sortedRight = [...right].sort()
-
-  return JSON.stringify(sortedLeft) === JSON.stringify(sortedRight)
-}
-
-function sameStepParameters(
-  left: Array<{ name: string; order: number; type: StepParameterType }>,
-  right: Array<{ name: string; order: number; type: StepParameterType }>,
-): boolean {
-  if (left.length !== right.length) {
-    return false
-  }
-
-  return left.every((parameter, index) => {
-    const other = right[index]
-    return (
-      parameter.name === other?.name &&
-      parameter.order === other?.order &&
-      parameter.type === other?.type
-    )
-  })
-}
-
-function sameResolvedParameters(
-  left: Array<{ name: string; value: string; order: number; type: StepParameterType }>,
-  right: Array<{ name: string; value: string; order: number; type: StepParameterType }>,
-): boolean {
-  if (left.length !== right.length) {
-    return false
-  }
-
-  return left.every((parameter, index) => {
-    const other = right[index]
-    return (
-      parameter.name === other?.name &&
-      parameter.value === other?.value &&
-      parameter.order === other?.order &&
-      parameter.type === other?.type
-    )
-  })
-}
-
-async function buildFilesystemSnapshot(baseDir: string): Promise<FilesystemSnapshot> {
-  const featuresDir = getAutomationFeaturesDir()
-  const [environments, parsedFeatures, locatorFiles, locatorMap, stepFiles] = await Promise.all([
-    readEnvironmentsFromFile(),
-    scanFeatureFiles(featuresDir),
-    scanLocatorFiles(baseDir),
-    readLocatorMap(baseDir),
-    scanStepFiles(baseDir),
-  ])
-
-  const locatorRouteMap = new Map(locatorMap.map(entry => [entry.name, entry.path]))
-  const locatorGroups: LocatorGroupFromFs[] = []
-  const locatorFileData: LocatorFileData[] = []
-  const directModulePaths = new Set<string>()
-
-  for (const filePath of locatorFiles) {
-    const modulePath = extractModulePathFromAutomationFile(filePath, baseDir, 'locators')
-    const groupName = extractLocatorGroupName(filePath)
-    const locators = await readLocatorFile(filePath)
-
-    locatorGroups.push({
-      name: groupName,
-      route: locatorRouteMap.get(groupName) ?? `/${groupName}`,
-      modulePath,
-    })
-    locatorFileData.push({
-      groupName,
-      modulePath,
-      locators,
-    })
-    directModulePaths.add(modulePath)
-  }
-
-  for (const feature of parsedFeatures) {
-    directModulePaths.add(extractModulePathFromFilePath(feature.filePath, featuresDir))
-  }
-
-  const tagObjects = buildTagObjects(extractUniqueTags(parsedFeatures))
-
-  const templateStepGroups: StepGroupJSDoc[] = []
-  const templateSteps: TemplateStepFromFs[] = []
-
-  for (const file of stepFiles) {
-    try {
-      const filePath = join(baseDir, file)
-      const content = await fs.readFile(filePath, 'utf-8')
-      const parsed = parseStepFile(content)
-      if (!parsed) {
-        continue
-      }
-
-      await Promise.all(
-        parsed.steps.map(async step => {
-          step.normalizedFunctionDefinition = await normalizeFunctionDefinition(step.functionDefinition)
-        }),
-      )
-
-      templateStepGroups.push(parsed.group)
-      for (const step of parsed.steps) {
-        templateSteps.push({
-          step,
-          groupName: parsed.group.name,
-          groupType: parsed.group.type,
-        })
-      }
-    } catch (error) {
-      console.error(`Unable to parse step file ${file} for sync counts:`, error)
-    }
-  }
-
-  const testSuites: TestSuiteFromFs[] = parsedFeatures.map(feature => ({
-    name: extractTestSuiteNameFromFilename(feature.filePath),
-    description: feature.featureDescription ?? feature.featureName ?? null,
-    modulePath: extractModulePathFromFilePath(feature.filePath, featuresDir),
-    tags: extractFeatureLevelTags(feature),
-  }))
-
-  const testCases: TestCaseFromFs[] = []
-  for (const feature of parsedFeatures) {
-    const modulePath = extractModulePathFromFilePath(feature.filePath, featuresDir)
-    const testSuiteName = extractTestSuiteNameFromFilename(feature.filePath)
-
-    for (const scenario of feature.scenarios) {
-      const flattenedTags = scenario.tags.flatMap(splitTagLine)
-      const identifierTag = flattenedTags.find(tag => tag.replace(/^@/, '').startsWith('tc_'))
-      if (!identifierTag) {
-        continue
-      }
-
-      const { title, description } = parseScenarioTitle(scenario.name, scenario.description)
-      testCases.push({
-        identifierTag: normalizeTagExpression(identifierTag),
-        title,
-        description,
-        testSuiteName,
-        modulePath,
-        filterTags: flattenedTags.filter(tag => normalizeTagExpression(tag) !== normalizeTagExpression(identifierTag)),
-        steps: scenario.steps,
-      })
-    }
-  }
-
-  return {
-    environments,
-    modulePaths: buildModuleTreePaths(directModulePaths),
-    locatorGroups,
-    locatorFiles: locatorFileData,
-    tagObjects,
-    templateStepGroups,
-    templateSteps,
-    testSuites,
-    testCases,
-  }
-}
-
-export function countModuleMismatches(
-  filesystemPaths: Set<string>,
-  dbModules: Array<{ id: string; name: string; path: string; parentId: string | null }>,
-): number {
-  const dbPaths = new Set<string>()
-  let rootExists = false
-
-  for (const dbModule of dbModules) {
-    if (dbModule.name === 'root' && dbModule.parentId === null) {
-      rootExists = true
-      continue
-    }
-
-    dbPaths.add(dbModule.path)
-  }
-
-  let count = 0
-  for (const modulePath of filesystemPaths) {
-    if (modulePath === '/') {
-      if (!rootExists) count++
-      continue
-    }
-
-    if (!dbPaths.has(modulePath)) {
-      count++
-    }
-  }
-
-  return count
-}
-
-function countEnvironmentMismatches(
-  filesystemEnvironments: EnvironmentData[],
-  dbEnvironments: Array<{ name: string }>,
-): number {
-  const fsByNormalizedName = new Map(
-    filesystemEnvironments.map(environment => [getEnvironmentIdentityKey(environment.name), environment]),
-  )
-  const dbByNormalizedName = new Map<string, { name: string }>()
-
-  for (const environment of dbEnvironments) {
-    const normalizedName = getEnvironmentIdentityKey(environment.name)
-    if (!dbByNormalizedName.has(normalizedName)) {
-      dbByNormalizedName.set(normalizedName, environment)
-    }
-  }
-
-  let count = 0
-  for (const environment of filesystemEnvironments) {
-    const existing = dbByNormalizedName.get(getEnvironmentIdentityKey(environment.name))
-    if (!existing) {
-      count++
-    }
-  }
-
-  for (const environment of dbEnvironments) {
-    if (!fsByNormalizedName.has(getEnvironmentIdentityKey(environment.name))) {
-      count++
-    }
-  }
-
-  return count
-}
-
-export function countTagMismatches(
-  filesystemTags: Array<{ name: string; tagExpression: string; type: TagType }>,
-  dbTags: Array<{ name: string; type: TagType }>,
-): number {
-  const dbByName = groupRecordsByKey(dbTags, tag => tag.name)
-
-  let count = 0
-  for (const tag of filesystemTags) {
-    const hasMatch = (dbByName.get(tag.name) ?? []).some(existing => existing.type === tag.type)
-    if (!hasMatch) {
-      count++
-    }
-  }
-
-  return count
-}
-
-export function countTemplateStepGroupMismatches(
-  filesystemGroups: StepGroupJSDoc[],
-  dbGroups: Array<{ name: string; description: string | null; type: TemplateStepGroupType }>,
-): number {
-  const dbByName = groupRecordsByKey(dbGroups, group => group.name)
-  let count = 0
-
-  for (const group of filesystemGroups) {
-    const hasMatch = (dbByName.get(group.name) ?? []).some(existing => {
-      return (existing.description ?? null) === (group.description ?? null) && existing.type === group.type
-    })
-
-    if (!hasMatch) {
-      count++
-    }
-  }
-
-  return count
-}
-
-export function countTemplateStepMismatches(
-  filesystemSteps: TemplateStepFromFs[],
-  dbSteps: Array<{
-    signature: string
-    name: string
-    description: string | null
-    functionDefinition: string | null
-    icon: TemplateStepIcon
-    type: TemplateStepType
-    templateStepGroup: { name: string }
-    parameters: Array<{ name: string; order: number; type: StepParameterType }>
-  }>,
-): number {
-  const dbBySignature = groupRecordsByKey(dbSteps, step => step.signature)
-  let count = 0
-
-  for (const item of filesystemSteps) {
-    const expectedType =
-      item.groupType === TemplateStepGroupType.ACTION ? TemplateStepType.ACTION : TemplateStepType.ASSERTION
-
-    const hasMatch = (dbBySignature.get(item.step.signature) ?? []).some(existing => {
-      return (
-        existing.name === item.step.jsdoc.name &&
-        (existing.description ?? '') === (item.step.jsdoc.description ?? '') &&
-        (existing.functionDefinition ?? '') === item.step.normalizedFunctionDefinition &&
-        existing.icon === item.step.jsdoc.icon &&
-        existing.type === expectedType &&
-        existing.templateStepGroup.name === item.groupName &&
-        sameStepParameters(existing.parameters, item.step.parameters)
-      )
-    })
-
-    if (!hasMatch) {
-      count++
-    }
-  }
-
-  return count
-}
-
-function countLocatorGroupMismatches(
-  filesystemGroups: LocatorGroupFromFs[],
-  dbGroups: Array<{ name: string; route: string; moduleId: string }>,
-  modulePathMap: Map<string, string>,
-): number {
-  const fsByName = new Map(filesystemGroups.map(group => [group.name, group]))
-  const dbByName = new Map(dbGroups.map(group => [group.name, group]))
-  let count = 0
-
-  for (const group of filesystemGroups) {
-    const existing = dbByName.get(group.name)
-    if (!existing) {
-      count++
-      continue
-    }
-
-    const existingModulePath = modulePathMap.get(existing.moduleId) ?? '/'
-    if (existing.route !== group.route || existingModulePath !== group.modulePath) {
-      count++
-    }
-  }
-
-  for (const group of dbGroups) {
-    if (!fsByName.has(group.name)) {
-      count++
-    }
-  }
-
-  return count
-}
-
-function countLocatorMismatches(
-  filesystemLocatorFiles: LocatorFileData[],
-  dbGroups: Array<{
-    name: string
-    locators: Array<{ name: string; value: string }>
-  }>,
-): number {
-  const dbGroupsByName = new Map(dbGroups.map(group => [group.name, group]))
-  let count = 0
-
-  for (const file of filesystemLocatorFiles) {
-    const dbGroup = dbGroupsByName.get(file.groupName)
-    const fileLocators = Object.entries(file.locators)
-
-    if (!dbGroup) {
-      count += fileLocators.length
-      continue
-    }
-
-    const dbLocators = new Map(dbGroup.locators.map(locator => [locator.name, locator.value]))
-    const fileLocatorNames = new Set<string>()
-
-    for (const [name, value] of fileLocators) {
-      fileLocatorNames.add(name)
-      if (!dbLocators.has(name) || dbLocators.get(name) !== value) {
-        count++
-      }
-    }
-
-    for (const locator of dbGroup.locators) {
-      if (!fileLocatorNames.has(locator.name)) {
-        count++
-      }
-    }
-  }
-
-  return count
-}
-
-export function countTestSuiteMismatches(
-  filesystemSuites: TestSuiteFromFs[],
-  dbSuites: Array<{
-    name: string
-    description: string | null
-    moduleId: string
-    tags: Array<{ tagExpression: string }>
-  }>,
-  modulePathMap: Map<string, string>,
-): number {
-  const dbByKey = groupRecordsByKey(dbSuites, suite =>
-    getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/'),
-  )
-  let count = 0
-
-  for (const suite of filesystemSuites) {
-    const suiteKey = getTestSuiteSyncIdentity(suite.name, suite.modulePath)
-    const fsTagExpressions = suite.tags.map(normalizeTagExpression)
-    const hasMatch = (dbByKey.get(suiteKey) ?? []).some(existing => {
-      const dbTagExpressions = existing.tags.map(tag => normalizeTagExpression(tag.tagExpression))
-      const expectedDescription = existing.description ?? existing.name
-      return expectedDescription === (suite.description ?? null) && sameStringSet(dbTagExpressions, fsTagExpressions)
-    })
-
-    if (!hasMatch) {
-      count++
-    }
-  }
-
-  return count
-}
-
-function hasProjectedTestCaseStepMismatch(
-  stepsFromFs: ParsedStep[],
-  dbSteps: Array<{
-    order: number
-    gherkinStep: string
-    label: string
-    icon: TemplateStepIcon
-    TemplateStep: { signature: string } | null
-    parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
-  }>,
-  dbTemplateSteps: Array<{
-    signature: string
-    parameters: Array<{ name: string; order: number; type: StepParameterType }>
-  }>,
-): boolean {
-  const projectedDbSteps = normalizeProjectedDbTestCaseSteps(dbSteps)
-  const dbStepsByOrder = new Map(projectedDbSteps.map(step => [step.order, step]))
-
-  for (const step of stepsFromFs) {
-    const existing = dbStepsByOrder.get(step.order)
-    const matchedTemplateStep = matchGherkinStepToTemplateStep(step, dbTemplateSteps)
-
-    if (!existing || !matchedTemplateStep) {
-      return true
-    }
-
-    const expectedIcon = determineProjectedStepIcon(step.keyword)
-    const expectedGherkinStep = `${step.keyword} ${step.text}`
-
-    if (
-      existing.gherkinStep !== expectedGherkinStep ||
-      existing.label !== step.text ||
-      existing.icon !== expectedIcon ||
-      existing.templateStepSignature !== matchedTemplateStep.signature ||
-      !sameResolvedParameters(existing.parameters, matchedTemplateStep.parameters)
-    ) {
-      return true
-    }
-  }
-
-  const fsOrders = new Set(stepsFromFs.map(step => step.order))
-  return projectedDbSteps.some(step => !fsOrders.has(step.order))
-}
-
-export function countTestCaseMismatches(
-  filesystemTestCases: TestCaseFromFs[],
-  dbTestCases: Array<{
-    title: string
-    description: string
-    tags: Array<{ tagExpression: string; type: TagType }>
-    TestSuite: Array<{ name: string; moduleId: string }>
-    steps: Array<{
-      order: number
-      gherkinStep: string
-      label: string
-      icon: TemplateStepIcon
-      TemplateStep: { signature: string } | null
-      parameters: Array<{ name: string; value: string; order: number; type: StepParameterType }>
-    }>
-  }>,
-  modulePathMap: Map<string, string>,
-  dbTemplateSteps: Array<{
-    signature: string
-    parameters: Array<{ name: string; order: number; type: StepParameterType }>
-  }>,
-): number {
-  const dbByIdentifier = new Map<string, Array<(typeof dbTestCases)[number]>>()
-  let count = 0
-
-  for (const testCase of dbTestCases) {
-    const identifierTag = testCase.tags.find(tag => tag.type === TagType.IDENTIFIER)
-    if (!identifierTag) {
-      continue
-    }
-
-    const normalizedIdentifier = normalizeTagExpression(identifierTag.tagExpression)
-    const existing = dbByIdentifier.get(normalizedIdentifier)
-    if (existing) {
-      existing.push(testCase)
-      continue
-    }
-
-    dbByIdentifier.set(normalizedIdentifier, [testCase])
-  }
-
-  for (const testCase of filesystemTestCases) {
-    const expectedSuiteIdentity = getTestSuiteSyncIdentity(testCase.testSuiteName, testCase.modulePath)
-    const normalizedFilterTags = testCase.filterTags.map(normalizeTagExpression)
-    const hasMatch = (dbByIdentifier.get(testCase.identifierTag) ?? []).some(existing => {
-      const existingFilterTags = existing.tags
-        .filter(tag => tag.type === TagType.FILTER)
-        .map(tag => normalizeTagExpression(tag.tagExpression))
-      const isLinkedToExpectedSuite = existing.TestSuite.some(
-        suite => getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/') === expectedSuiteIdentity,
-      )
-
-      return (
-        existing.title === testCase.title &&
-        existing.description === testCase.description &&
-        isLinkedToExpectedSuite &&
-        sameStringSet(existingFilterTags, normalizedFilterTags) &&
-        !hasProjectedTestCaseStepMismatch(testCase.steps, existing.steps, dbTemplateSteps)
-      )
-    })
-
-    if (!hasMatch) {
-      count++
-    }
-  }
-
-  return count
-}
-
-function emptyCounts(): SyncPendingCounts {
-  const counts = Object.fromEntries(syncScriptDefinitions.map(definition => [definition.id, 0])) as Record<SyncScriptId, number>
-  return {
-    ...counts,
-    [SYNC_ALL_REQUEST_ID]: 0,
-  }
-}
-
-export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
-  try {
-    await ensureAutomationWorkspaceReady()
-
-    const baseDir = process.cwd()
-    const filesystem = await buildFilesystemSnapshot(baseDir)
-    const [
-      dbModules,
-      dbEnvironments,
-      dbTags,
-      dbTemplateStepGroups,
-      dbTemplateSteps,
-      dbLocatorGroups,
-      dbTestSuites,
-      dbTestCases,
-    ] = await Promise.all([
-      getAllModulesWithPaths(),
-      prisma.environment.findMany({ select: { name: true } }),
-      prisma.tag.findMany({ select: { name: true, type: true } }),
-      prisma.templateStepGroup.findMany({ select: { name: true, description: true, type: true } }),
-      prisma.templateStep.findMany({
-        select: {
-          signature: true,
-          name: true,
-          description: true,
-          functionDefinition: true,
-          icon: true,
-          type: true,
-          parameters: {
-            select: { name: true, order: true, type: true },
-            orderBy: { order: 'asc' },
-          },
-          templateStepGroup: {
-            select: { name: true },
-          },
-        },
-      }),
-      prisma.locatorGroup.findMany({
-        select: {
-          name: true,
-          route: true,
-          moduleId: true,
-          locators: {
-            select: { name: true, value: true },
-          },
-        },
-      }),
-      prisma.testSuite.findMany({
-        select: {
-          name: true,
-          description: true,
-          moduleId: true,
-          tags: {
-            select: { tagExpression: true },
-          },
-        },
-      }),
-      prisma.testCase.findMany({
-        select: {
-          title: true,
-          description: true,
-          tags: {
-            select: { tagExpression: true, type: true },
-          },
-          TestSuite: {
-            select: { name: true, moduleId: true },
-          },
-          steps: {
-            orderBy: { order: 'asc' },
-            select: {
-              order: true,
-              gherkinStep: true,
-              label: true,
-              icon: true,
-              TemplateStep: {
-                select: { signature: true },
-              },
-              parameters: {
-                select: { name: true, value: true, order: true, type: true },
-                orderBy: { order: 'asc' },
-              },
-            },
-          },
-        },
-      }),
-    ])
-
-    const normalizedDbTemplateSteps = await Promise.all(
-      dbTemplateSteps.map(async step => ({
-        ...step,
-        functionDefinition: await normalizeFunctionDefinition(step.functionDefinition),
-      })),
-    )
-
-    const modulePathMap = new Map(dbModules.map(module => [module.id, module.name === 'root' && module.parentId === null ? '/' : module.path]))
-
-    const counts: Record<SyncScriptId, number> = {
-      'sync-modules': countModuleMismatches(filesystem.modulePaths, dbModules),
-      'sync-environments': countEnvironmentMismatches(filesystem.environments, dbEnvironments),
-      'sync-tags': countTagMismatches(filesystem.tagObjects, dbTags),
-      'sync-template-step-groups': countTemplateStepGroupMismatches(filesystem.templateStepGroups, dbTemplateStepGroups),
-      'sync-template-steps': countTemplateStepMismatches(filesystem.templateSteps, normalizedDbTemplateSteps),
-      'sync-locator-groups': countLocatorGroupMismatches(filesystem.locatorGroups, dbLocatorGroups, modulePathMap),
-      'sync-locators': countLocatorMismatches(filesystem.locatorFiles, dbLocatorGroups),
-      'sync-test-suites': countTestSuiteMismatches(filesystem.testSuites, dbTestSuites, modulePathMap),
-      'sync-test-cases': countTestCaseMismatches(
-        filesystem.testCases,
-        dbTestCases,
-        modulePathMap,
-        normalizedDbTemplateSteps.map(step => ({
-          signature: step.signature,
-          parameters: step.parameters,
-        })),
-      ),
-    }
-
-    return {
-      ...counts,
-      [SYNC_ALL_REQUEST_ID]: Object.values(counts).reduce((sum, count) => sum + count, 0),
-    }
-  } catch (error) {
-    console.error('Unable to compute sync pending counts:', error)
-    return emptyCounts()
-  }
-}