create-appraisejs 0.3.0 → 0.3.1-alpha.0

package/templates/starter/src/lib/process/task-spawner.ts

@@ -24,7 +24,7 @@ export interface SpawnedProcess {
   endTime: Date | null
 }
 
-export class TaskSpawner extends EventEmitter {
+class TaskSpawner extends EventEmitter {
   private processes: Map<string, SpawnedProcess> = new Map()
   private processCounter = 0
   private outputBuffers: Map<string, { stdout: string; stderr: string }> = new Map()
@@ -158,6 +158,54 @@ export class TaskSpawner extends EventEmitter {
     }
   }
 
+  private emitOutputLine(
+    processName: string,
+    stream: 'stdout' | 'stderr',
+    data: string,
+    streamLogs: boolean,
+    prefixLogs: boolean,
+    captureOutput: boolean,
+    spawnedProcess: SpawnedProcess,
+  ): void {
+    if (captureOutput) {
+      spawnedProcess.output[stream].push(data)
+    }
+
+    if (streamLogs) {
+      const prefix = prefixLogs ? `[${processName}] ` : ''
+      if (stream === 'stdout') {
+        console.log(`${prefix}${data}`)
+      } else {
+        console.error(`${prefix}${data}`)
+      }
+    }
+
+    this.emit(stream, { processName, data })
+  }
+
+  private flushBufferedOutput(
+    processName: string,
+    streamLogs: boolean,
+    prefixLogs: boolean,
+    captureOutput: boolean,
+    spawnedProcess: SpawnedProcess,
+  ): void {
+    const buffer = this.outputBuffers.get(processName)
+    if (!buffer) {
+      return
+    }
+
+    if (buffer.stdout) {
+      this.emitOutputLine(processName, 'stdout', buffer.stdout, streamLogs, prefixLogs, captureOutput, spawnedProcess)
+    }
+
+    if (buffer.stderr) {
+      this.emitOutputLine(processName, 'stderr', buffer.stderr, streamLogs, prefixLogs, captureOutput, spawnedProcess)
+    }
+
+    this.outputBuffers.delete(processName)
+  }
+
   private setupProcessListeners(
     spawnedProcess: SpawnedProcess,
     options: {
@@ -195,32 +243,7 @@ export class TaskSpawner extends EventEmitter {
 
     childProcess.on('exit', (code: number | null) => {
       if (stdioConfig === 'pipe') {
-        const buffer = this.outputBuffers.get(name)
-        if (buffer) {
-          if (buffer.stdout) {
-            if (captureOutput) {
-              spawnedProcess.output.stdout.push(buffer.stdout)
-            }
-            if (streamLogs) {
-              const prefix = prefixLogs ? `[${name}] ` : ''
-              console.log(`${prefix}${buffer.stdout}`)
-            }
-            this.emit('stdout', { processName: name, data: buffer.stdout })
-          }
-
-          if (buffer.stderr) {
-            if (captureOutput) {
-              spawnedProcess.output.stderr.push(buffer.stderr)
-            }
-            if (streamLogs) {
-              const prefix = prefixLogs ? `[${name}] ` : ''
-              console.error(`${prefix}${buffer.stderr}`)
-            }
-            this.emit('stderr', { processName: name, data: buffer.stderr })
-          }
-
-          this.outputBuffers.delete(name)
-        }
+        this.flushBufferedOutput(name, streamLogs, prefixLogs, captureOutput, spawnedProcess)
       }
 
       spawnedProcess.isRunning = false

package/templates/starter/src/lib/sync/projected-feature-utils.ts

@@ -1,4 +1,5 @@
 import { StepParameterType, TemplateStepIcon } from '@prisma/client'
+import { formatOrderedGherkinSteps } from '@/lib/gherkin-step-format'
 
 type StoredProjectedStep = {
   order: number
@@ -38,48 +39,7 @@ export function generateProjectedGherkinSteps(steps: StoredProjectedStep[]): str
     return []
   }
 
-  const sortedSteps = [...steps].sort((left, right) => left.order - right.order)
-  let hasThenInPrevious = false
-  let hasWhenInPrevious = false
-
-  return sortedSteps.map((step, index) => {
-    const gherkinStep = step.gherkinStep?.trim() || ''
-    const firstWord = gherkinStep.split(' ')[0].toLowerCase()
-    const hasGherkinKeyword = ['given', 'when', 'then', 'and', 'but'].includes(firstWord)
-    const stepWithoutKeyword = hasGherkinKeyword ? gherkinStep.split(' ').slice(1).join(' ') : gherkinStep
-
-    if (index === 0) {
-      return `Given ${stepWithoutKeyword}`
-    }
-
-    const isThenStatement =
-      firstWord === 'then' ||
-      stepWithoutKeyword.toLowerCase().startsWith('should') ||
-      stepWithoutKeyword.toLowerCase().startsWith('must') ||
-      stepWithoutKeyword.toLowerCase().startsWith('will')
-
-    if (!hasThenInPrevious) {
-      if (isThenStatement) {
-        hasThenInPrevious = true
-        return `Then ${stepWithoutKeyword}`
-      }
-
-      if (!hasWhenInPrevious) {
-        hasWhenInPrevious = true
-        return `When ${stepWithoutKeyword}`
-      }
-
-      return `And ${stepWithoutKeyword}`
-    }
-
-    if (isThenStatement) {
-      return `And ${stepWithoutKeyword}`
-    }
-
-    hasThenInPrevious = false
-    hasWhenInPrevious = true
-    return `When ${stepWithoutKeyword}`
-  })
+  return formatOrderedGherkinSteps(steps)
 }
 
 export function determineProjectedStepIcon(keyword: string): TemplateStepIcon {

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

@@ -6,26 +6,36 @@ 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 { StepParameterType, TagType, TemplateStepGroupType, TemplateStepIcon, TemplateStepType } from '@prisma/client'
 import prisma from '@/config/db-config'
 import { getAutomationEnvironmentsDir, getAutomationFeaturesDir } from '@/lib/automation/automation-path-roots'
 import { ensureAutomationWorkspaceReady } from '@/lib/automation/automation-workspace'
-import { extractModulePathFromFilePath, scanFeatureFiles, type ParsedFeature, type ParsedStep } from '@/lib/gherkin-parser'
+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 {
+  SYNC_ALL_REQUEST_ID,
+  syncScriptDefinitions,
+  type SyncRequestId,
+  type SyncScriptId,
+} from '@/lib/sync/sync-registry'
+import { getTagTypeFromName } from '@/lib/tag-identifiers'
 import { extractModulePathFromAutomationFile, getAutomationLocatorMapPath } from '@/lib/template-sync-utils'
 import {
   determineProjectedStepIcon,
   getTestSuiteSyncIdentity,
   normalizeProjectedDbTestCaseSteps,
 } from '@/lib/sync/projected-feature-utils'
+import {
+  parseGroupJSDocLenient as parseGroupJSDoc,
+  parseStepJSDocLenient as parseStepJSDoc,
+  type StepGroupJSDoc,
+  type StepJSDoc,
+} from '@/lib/jsdoc/template-step-jsdoc'
 
 const traverse = (_traverse as { default?: typeof _traverse }).default ?? _traverse
 
@@ -63,18 +73,6 @@ type LocatorFileData = {
   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
@@ -95,6 +93,8 @@ type ParsedStepFile = {
   steps: ParsedTemplateStep[]
 }
 
+type StepKeyword = ParsedTemplateStep['keyword']
+
 type TemplateStepFromFs = {
   step: ParsedTemplateStep
   groupName: string
@@ -296,201 +296,120 @@ async function readLocatorFile(filePath: string): Promise<Record<string, string>
   }
 }
 
-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
-  }
+function mapTypeToParameterType(typeName: string): StepParameterType {
+  const normalized = typeName.trim()
 
-  if (startLine >= lines.length || !lines[startLine].trim().startsWith('/**')) {
-    return null
-  }
+  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
 
-  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()
-        }
-      }
+  throw new Error(`Unsupported parameter type: ${typeName}`)
+}
 
-      endLine = i
-      break
-    }
+function extractFunctionDefinition(callExpression: t.CallExpression, sourceCode: string): string {
+  const start = callExpression.start
+  const end = callExpression.end
 
-    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 (start == null || end == null) {
+    throw new Error('Cannot extract function definition.')
   }
 
-  if (!hasType || endLine < 0 || !name || !type) {
-    return null
+  let code = sourceCode.slice(start, end).trim()
+  const trailingSource = sourceCode.slice(end, end + 10).trim()
+  if (trailingSource.startsWith(';')) {
+    code += ';'
   }
 
-  const normalizedType = type.toUpperCase()
-  if (normalizedType !== 'ACTION' && normalizedType !== 'VALIDATION') {
-    return null
-  }
+  return code
+}
 
-  return {
-    name: name.trim(),
-    description: description ? description.trim() : null,
-    type: normalizedType as TemplateStepGroupType,
-  }
+function getStepKeyword(node: t.CallExpression): StepKeyword | null {
+  const callee = node.callee
+  return t.isIdentifier(callee) && (callee.name === 'When' || callee.name === 'Then' || callee.name === 'Given')
+    ? callee.name
+    : null
 }
 
-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
-    }
+function getStepSignature(node: t.CallExpression): string | null {
+  const patternArg = node.arguments[0]
+  return t.isStringLiteral(patternArg) ? patternArg.value : null
+}
 
-    if (line?.startsWith('/**')) {
-      jsdocStart = i
-      break
-    }
-  }
+function getStepFunction(node: t.CallExpression): t.Function | null {
+  const functionArg = node.arguments[1]
+  return t.isFunction(functionArg) ? functionArg : null
+}
 
-  if (jsdocStart === -1) {
+function getIdentifierParameterType(parameter: t.Identifier): string | null {
+  if (!parameter.typeAnnotation || !t.isTSTypeAnnotation(parameter.typeAnnotation)) {
     return null
   }
 
-  let name: string | null = null
-  let description: string | null = null
-  let icon: string | null = null
-  let foundJSDoc = false
+  const annotation = parameter.typeAnnotation.typeAnnotation
+  if (t.isTSTypeReference(annotation) && t.isIdentifier(annotation.typeName)) {
+    return annotation.typeName.name
+  }
+
+  if (t.isTSStringKeyword(annotation)) return 'string'
+  if (t.isTSNumberKeyword(annotation)) return 'number'
+  if (t.isTSBooleanKeyword(annotation)) return 'boolean'
+  return null
+}
 
-  for (let i = jsdocStart; i < Math.min(lines.length, jsdocStart + 20); i++) {
-    const line = lines[i]?.trim()
+function parseStepParameters(parameters: t.Function['params']): StepParameter[] | null {
+  const parsedParameters: StepParameter[] = []
 
-    if (line?.startsWith('/**')) {
-      foundJSDoc = true
+  for (const parameter of parameters) {
+    if ((t.isIdentifier(parameter) && parameter.name === 'this') || t.isObjectPattern(parameter)) {
       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 (!t.isIdentifier(parameter)) {
+      continue
     }
 
-    if (!foundJSDoc) {
+    const typeName = getIdentifierParameterType(parameter)
+    if (!typeName) {
       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()
+    try {
+      parsedParameters.push({
+        name: parameter.name,
+        type: mapTypeToParameterType(typeName),
+        order: parsedParameters.length,
+      })
+    } catch {
+      return null
     }
   }
 
-  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,
-  }
+  return parsedParameters
 }
 
-function mapTypeToParameterType(typeName: string): StepParameterType {
-  const normalized = typeName.trim()
+function parseStepCall(node: t.CallExpression, content: string): ParsedTemplateStep | null {
+  const keyword = getStepKeyword(node)
+  if (!keyword || node.arguments.length < 2) return null
 
-  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
+  const signature = getStepSignature(node)
+  const functionArg = getStepFunction(node)
+  const lineNumber = node.loc?.start?.line
+  if (!signature || !functionArg || lineNumber == null) return null
 
-  throw new Error(`Unsupported parameter type: ${typeName}`)
-}
+  const jsdoc = parseStepJSDoc(content, lineNumber - 1)
+  const parameters = parseStepParameters(functionArg.params)
+  if (!jsdoc || !parameters) return null
 
-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 {
+    jsdoc,
+    signature,
+    functionDefinition: extractFunctionDefinition(node, content),
+    normalizedFunctionDefinition: '',
+    parameters,
+    keyword,
   }
-
-  return code
 }
 
 function parseStepFile(content: string): ParsedStepFile | null {
@@ -508,87 +427,8 @@ function parseStepFile(content: string): ParsedStepFile | null {
 
   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,
-      })
+      const step = parseStepCall(path.node, content)
+      if (step) steps.push(step)
     },
   })
 
@@ -610,7 +450,10 @@ function extractFeatureLevelTags(parsedFeature: ParsedFeature): string[] {
   return parsedFeature.tags.flatMap(splitTagLine)
 }
 
-function parseScenarioTitle(scenarioName: string, scenarioDescription?: string): { title: string; description: string } {
+function parseScenarioTitle(
+  scenarioName: string,
+  scenarioDescription?: string,
+): { title: string; description: string } {
   if (scenarioDescription) {
     return {
       title: scenarioDescription.trim(),
@@ -673,7 +516,11 @@ function matchGherkinStepToTemplateStep(
   }>,
 ): { signature: string; parameters: ParameterMatch[] } | null {
   for (const templateStep of templateSteps) {
-    const parameters = extractParametersFromGherkinStep(gherkinStep.text, templateStep.signature, templateStep.parameters)
+    const parameters = extractParametersFromGherkinStep(
+      gherkinStep.text,
+      templateStep.signature,
+      templateStep.parameters,
+    )
     if (parameters) {
       return {
         signature: templateStep.signature,
@@ -723,11 +570,7 @@ function sameStepParameters(
 
   return left.every((parameter, index) => {
     const other = right[index]
-    return (
-      parameter.name === other?.name &&
-      parameter.order === other?.order &&
-      parameter.type === other?.type
-    )
+    return parameter.name === other?.name && parameter.order === other?.order && parameter.type === other?.type
   })
 }
 
@@ -1201,7 +1044,8 @@ export function countTestCaseMismatches(
         .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,
+        suite =>
+          getTestSuiteSyncIdentity(suite.name, modulePathMap.get(suite.moduleId) ?? '/') === expectedSuiteIdentity,
       )
 
       return (
@@ -1222,7 +1066,10 @@ export function countTestCaseMismatches(
 }
 
 function emptyCounts(): SyncPendingCounts {
-  const counts = Object.fromEntries(syncScriptDefinitions.map(definition => [definition.id, 0])) as Record<SyncScriptId, number>
+  const counts = Object.fromEntries(syncScriptDefinitions.map(definition => [definition.id, 0])) as Record<
+    SyncScriptId,
+    number
+  >
   return {
     ...counts,
     [SYNC_ALL_REQUEST_ID]: 0,
@@ -1323,13 +1170,18 @@ export async function getSyncPendingCounts(): Promise<SyncPendingCounts> {
       })),
     )
 
-    const modulePathMap = new Map(dbModules.map(module => [module.id, module.name === 'root' && module.parentId === null ? '/' : module.path]))
+    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-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),