create-appraisejs 0.1.8 → 0.1.10-alpha.0

package/templates/default/src/lib/locator-group-file-utils.ts

@@ -2,35 +2,36 @@ import { promises as fs } from 'fs'
 import path from 'path'
 import prisma from '@/config/db-config'
 import { buildModulePath } from '@/lib/path-helpers/module-path'
+import {
+  ensureAutomationWorkspaceReady,
+  getAutomationLocatorsDir,
+  getAutomationMappingDir,
+} from '@/lib/automation/paths'
 
-/**
- * Gets the file path for a locator group based on its module hierarchy
- */
 export async function getLocatorGroupFilePath(locatorGroupId: string): Promise<string | null> {
   try {
+    await ensureAutomationWorkspaceReady()
     const locatorGroup = await prisma.locatorGroup.findUnique({
       where: { id: locatorGroupId },
       include: { module: true },
     })
 
-    if (!locatorGroup) return null
+    if (!locatorGroup) {
+      return null
+    }
 
     const allModules = await prisma.module.findMany()
     const modulePath = buildModulePath(allModules, locatorGroup.module)
-
     const sanitizedPath = modulePath.replace(/^\//, '').replace(/\//g, path.sep)
     const fileName = `${locatorGroup.name}.json`
 
-    return path.join('src', 'tests', 'locators', sanitizedPath, fileName)
+    return path.join(getAutomationLocatorsDir(), sanitizedPath, fileName)
   } catch (error) {
     console.error('Error getting locator group file path:', error)
     return null
   }
 }
 
-/**
- * Generates JSON content for a locator group from its locators
- */
 export async function generateLocatorGroupContent(locatorGroupId: string): Promise<Record<string, string>> {
   try {
     const locatorGroup = await prisma.locatorGroup.findUnique({
@@ -42,7 +43,9 @@ export async function generateLocatorGroupContent(locatorGroupId: string): Promi
       },
     })
 
-    if (!locatorGroup) return {}
+    if (!locatorGroup) {
+      return {}
+    }
 
     return Object.fromEntries(locatorGroup.locators.map(locator => [locator.name, locator.value]))
   } catch (error) {
@@ -51,29 +54,21 @@ export async function generateLocatorGroupContent(locatorGroupId: string): Promi
   }
 }
 
-/**
- * Ensures a directory exists, creating it if necessary
- */
 export async function ensureDirectoryExists(filePath: string): Promise<void> {
-  const dir = path.dirname(filePath)
-  try {
-    await fs.access(dir)
-  } catch {
-    await fs.mkdir(dir, { recursive: true })
-  }
+  await ensureAutomationWorkspaceReady()
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
 }
 
-/**
- * Creates or updates a locator group JSON file
- */
 export async function createOrUpdateLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
   try {
+    await ensureAutomationWorkspaceReady()
     const filePath = await getLocatorGroupFilePath(locatorGroupId)
-    if (!filePath) return false
+    if (!filePath) {
+      return false
+    }
 
     await ensureDirectoryExists(filePath)
     const content = await generateLocatorGroupContent(locatorGroupId)
-
     await fs.writeFile(filePath, JSON.stringify(content, null, 2))
     return true
   } catch (error) {
@@ -82,19 +77,18 @@ export async function createOrUpdateLocatorGroupFile(locatorGroupId: string): Pr
   }
 }
 
-/**
- * Deletes a locator group JSON file and cleans up empty directories
- */
-export async function deleteLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
+export async function deleteLocatorGroupFile(locatorGroupId: string, filePathOverride?: string): Promise<boolean> {
   try {
-    const filePath = await getLocatorGroupFilePath(locatorGroupId)
-    if (!filePath) return false
+    await ensureAutomationWorkspaceReady()
+    const filePath = filePathOverride ?? (await getLocatorGroupFilePath(locatorGroupId))
+    if (!filePath) {
+      return false
+    }
 
-    // Check if file exists before trying to delete
     try {
       await fs.access(filePath)
     } catch {
-      return true // File doesn't exist, nothing to delete
+      return true
     }
 
     await fs.unlink(filePath)
@@ -106,39 +100,26 @@ export async function deleteLocatorGroupFile(locatorGroupId: string): Promise<bo
   }
 }
 
-/**
- * Renames a locator group file when the name changes
- */
 export async function renameLocatorGroupFile(
-  oldLocatorGroupId: string,
+  locatorGroupId: string,
   newName: string,
   oldName?: string,
 ): Promise<boolean> {
   try {
-    // Get the current file path (with new name) for the directory
-    const currentFilePath = await getLocatorGroupFilePath(oldLocatorGroupId)
-    if (!currentFilePath) return false
-
-    // If oldName is provided, construct the old file path manually
-    // Otherwise, try to get it from the current path (fallback)
-    let oldFilePath: string
-    if (oldName) {
-      oldFilePath = path.join(path.dirname(currentFilePath), `${oldName}.json`)
-    } else {
-      oldFilePath = currentFilePath
+    await ensureAutomationWorkspaceReady()
+    const currentFilePath = await getLocatorGroupFilePath(locatorGroupId)
+    if (!currentFilePath) {
+      return false
     }
 
+    const oldFilePath = oldName ? path.join(path.dirname(currentFilePath), `${oldName}.json`) : currentFilePath
     const newFilePath = path.join(path.dirname(currentFilePath), `${newName}.json`)
 
     try {
       await fs.access(oldFilePath)
-      console.log('oldFilePath exists:', oldFilePath)
       await fs.rename(oldFilePath, newFilePath)
-      console.log('File renamed successfully from', oldFilePath, 'to', newFilePath)
-    } catch (error) {
-      console.log('File not found at old path, creating new one:', error)
-      // File doesn't exist, create new one
-      return await createOrUpdateLocatorGroupFile(oldLocatorGroupId)
+    } catch {
+      return createOrUpdateLocatorGroupFile(locatorGroupId)
     }
 
     return true
@@ -148,27 +129,25 @@ export async function renameLocatorGroupFile(
   }
 }
 
-/**
- * Moves a locator group file when the module changes
- */
-export async function moveLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
+export async function moveLocatorGroupFile(locatorGroupId: string, previousFilePath?: string): Promise<boolean> {
   try {
-    // Delete old file and create new one in correct location
-    await deleteLocatorGroupFile(locatorGroupId)
-    return await createOrUpdateLocatorGroupFile(locatorGroupId)
+    await ensureAutomationWorkspaceReady()
+    if (previousFilePath) {
+      await deleteLocatorGroupFile(locatorGroupId, previousFilePath)
+    }
+
+    return createOrUpdateLocatorGroupFile(locatorGroupId)
   } catch (error) {
     console.error('Error moving locator group file:', error)
     return false
   }
 }
 
-/**
- * Cleans up empty directories recursively
- */
 async function cleanupEmptyDirectories(filePath: string): Promise<void> {
   let currentDir = path.dirname(filePath)
+  const locatorsRoot = getAutomationLocatorsDir()
 
-  while (currentDir !== 'tests' && currentDir !== '.') {
+  while (currentDir.startsWith(locatorsRoot) && currentDir !== locatorsRoot && currentDir !== path.dirname(currentDir)) {
     try {
       const files = await fs.readdir(currentDir)
       if (files.length === 0) {
@@ -183,13 +162,13 @@ async function cleanupEmptyDirectories(filePath: string): Promise<void> {
   }
 }
 
-/**
- * Creates an empty JSON file for a new locator group
- */
 export async function createEmptyLocatorGroupFile(locatorGroupId: string): Promise<boolean> {
   try {
+    await ensureAutomationWorkspaceReady()
     const filePath = await getLocatorGroupFilePath(locatorGroupId)
-    if (!filePath) return false
+    if (!filePath) {
+      return false
+    }
 
     await ensureDirectoryExists(filePath)
     await fs.writeFile(filePath, JSON.stringify({}, null, 2))
@@ -200,46 +179,31 @@ export async function createEmptyLocatorGroupFile(locatorGroupId: string): Promi
   }
 }
 
-/**
- * Reads and parses the content of a locator group file
- */
 export async function readLocatorGroupFile(
   locatorGroupId: string,
 ): Promise<{ filePath: string; content: Record<string, string> } | null> {
   try {
+    await ensureAutomationWorkspaceReady()
     const filePath = await getLocatorGroupFilePath(locatorGroupId)
-    if (!filePath) return null
+    if (!filePath) {
+      return null
+    }
 
     const fileContent = await fs.readFile(filePath, 'utf-8')
-    const jsonContent = JSON.parse(fileContent)
-
-    return { filePath, content: jsonContent }
+    return { filePath, content: JSON.parse(fileContent) }
   } catch (error) {
     console.error('Error reading locator group file:', error)
     return null
   }
 }
 
-/**
- * Updates the locator map file with locator group information
- * Overload for updating existing entries (4 parameters)
- */
 export async function updateLocatorMapFile(
   currentLocatorGroupRoute: string,
   newLocatorGroupRoute: string,
   currentLocatorGroupName: string,
   newLocatorGroupName: string,
 ): Promise<boolean>
-
-/**
- * Updates the locator map file with locator group information
- * Overload for adding new entries (2 parameters)
- */
 export async function updateLocatorMapFile(newLocatorGroupName: string, newLocatorGroupRoute: string): Promise<boolean>
-
-/**
- * Implementation of updateLocatorMapFile with proper overload handling
- */
 export async function updateLocatorMapFile(
   param1: string,
   param2: string,
@@ -247,54 +211,43 @@ export async function updateLocatorMapFile(
   param4?: string,
 ): Promise<boolean> {
   try {
-    const locatorMapPath = path.join('src', 'tests', 'mapping', 'locator-map.json')
-
-    // Ensure the mapping directory exists
+    await ensureAutomationWorkspaceReady()
+    const locatorMapPath = path.join(getAutomationMappingDir(), 'locator-map.json')
     await ensureDirectoryExists(locatorMapPath)
 
     let locatorMap: Array<{ name: string; path: string }> = []
 
-    // Read existing locator map or create empty array
     try {
       const fileContent = await fs.readFile(locatorMapPath, 'utf-8')
       locatorMap = JSON.parse(fileContent)
     } catch {
-      // File doesn't exist, start with empty array
       locatorMap = []
     }
 
-    // Determine if this is a 2-param call (new entry) or 4-param call (update)
     const isNewEntry = param3 === undefined && param4 === undefined
 
     if (isNewEntry) {
-      // 2 params: newLocatorGroupName, newLocatorGroupRoute
       const name = param1
       const route = param2
-
-      // Check for uniqueness
       const existingEntry = locatorMap.find(entry => entry.name === name)
       if (existingEntry) {
         console.error(`Locator group with name "${name}" already exists in locator map`)
         return false
       }
 
-      // Add new entry
       locatorMap.push({ name, path: route })
     } else {
-      // 4 params: update existing entry
       const currentLocatorGroupRoute = param1
       const newLocatorGroupRoute = param2
       const currentLocatorGroupName = param3!
       const newLocatorGroupName = param4!
 
-      // Find the entry to update
       const entryIndex = locatorMap.findIndex(entry => entry.name === currentLocatorGroupName)
       if (entryIndex === -1) {
         console.error(`Locator group with name "${currentLocatorGroupName}" not found in locator map`)
         return false
       }
 
-      // Check if new name is unique (if name is changing)
       if (currentLocatorGroupName !== newLocatorGroupName) {
         const existingEntry = locatorMap.find(entry => entry.name === newLocatorGroupName)
         if (existingEntry) {
@@ -303,15 +256,12 @@ export async function updateLocatorMapFile(
         }
       }
 
-      // Update the entry
       const updatedEntry = { ...locatorMap[entryIndex] }
 
-      // Update name if it changed
       if (currentLocatorGroupName !== newLocatorGroupName) {
         updatedEntry.name = newLocatorGroupName
       }
 
-      // Update path if it changed
       if (currentLocatorGroupRoute !== newLocatorGroupRoute) {
         updatedEntry.path = newLocatorGroupRoute
       }
@@ -319,7 +269,6 @@ export async function updateLocatorMapFile(
       locatorMap[entryIndex] = updatedEntry
     }
 
-    // Write the updated locator map back to file
     await fs.writeFile(locatorMapPath, JSON.stringify(locatorMap, null, 2))
     return true
   } catch (error) {
@@ -328,40 +277,28 @@ export async function updateLocatorMapFile(
   }
 }
 
-/**
- * Removes locator group entries from the locator map file
- * @param locatorGroupNames - Array of locator group names to remove
- */
 export async function removeLocatorMapEntry(locatorGroupNames: string[]): Promise<boolean> {
   try {
-    const locatorMapPath = path.join('src', 'tests', 'mapping', 'locator-map.json')
+    await ensureAutomationWorkspaceReady()
+    const locatorMapPath = path.join(getAutomationMappingDir(), 'locator-map.json')
 
-    // Check if file exists
     try {
       await fs.access(locatorMapPath)
     } catch {
-      // File doesn't exist, nothing to remove
       return true
     }
 
-    // Read existing locator map
     const fileContent = await fs.readFile(locatorMapPath, 'utf-8')
     let locatorMap: Array<{ name: string; path: string }> = JSON.parse(fileContent)
 
-    // Filter out the entries to be removed
     const originalLength = locatorMap.length
     locatorMap = locatorMap.filter(entry => !locatorGroupNames.includes(entry.name))
 
-    // Check if any entries were actually removed
-    const removedCount = originalLength - locatorMap.length
-    if (removedCount === 0) {
-      console.log('No matching locator group entries found in locator map')
+    if (originalLength === locatorMap.length) {
       return true
     }
 
-    // Write the updated locator map back to file
     await fs.writeFile(locatorMapPath, JSON.stringify(locatorMap, null, 2))
-    console.log(`Removed ${removedCount} locator group entry(ies) from locator map`)
     return true
   } catch (error) {
     console.error('Error removing locator map entries:', error)

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

@@ -0,0 +1,236 @@
+import { execa, type Options as ExecaOptions } from 'execa'
+import type { ChildProcess } from 'child_process'
+import { EventEmitter } from 'events'
+
+export interface SpawnerOptions extends ExecaOptions {
+  streamLogs?: boolean
+  prefixLogs?: boolean
+  logPrefix?: string
+  captureOutput?: boolean
+}
+
+export interface SpawnedProcess {
+  process: ChildProcess
+  pid: number | undefined
+  name: string
+  output: {
+    stdout: string[]
+    stderr: string[]
+  }
+  isRunning: boolean
+  exitCode: number | null
+  startTime: Date
+  endTime: Date | null
+}
+
+export class TaskSpawner extends EventEmitter {
+  private processes: Map<string, SpawnedProcess> = new Map()
+  private processCounter = 0
+  private outputBuffers: Map<string, { stdout: string; stderr: string }> = new Map()
+
+  async spawn(command: string, args: string[] = [], options: SpawnerOptions = {}): Promise<SpawnedProcess> {
+    const { streamLogs = true, prefixLogs = true, logPrefix, captureOutput = false, ...spawnOptions } = options
+
+    const processName = logPrefix || `${command}_${++this.processCounter}`
+    const spawnedProcess: SpawnedProcess = {
+      process: null as unknown as ChildProcess,
+      pid: undefined,
+      name: processName,
+      output: {
+        stdout: [],
+        stderr: [],
+      },
+      isRunning: false,
+      exitCode: null,
+      startTime: new Date(),
+      endTime: null,
+    }
+
+    const stdioConfig = captureOutput ? 'pipe' : streamLogs ? 'inherit' : 'pipe'
+    const childProcess = execa(command, args, {
+      stdio: stdioConfig,
+      ...spawnOptions,
+    })
+
+    spawnedProcess.process = childProcess
+    spawnedProcess.pid = childProcess.pid
+    spawnedProcess.isRunning = true
+
+    this.processes.set(processName, spawnedProcess)
+    this.outputBuffers.set(processName, { stdout: '', stderr: '' })
+
+    this.setupProcessListeners(spawnedProcess, {
+      streamLogs,
+      prefixLogs,
+      captureOutput,
+      stdioConfig,
+    })
+
+    this.emit('spawn', spawnedProcess)
+    return spawnedProcess
+  }
+
+  killProcess(processName: string, signal: NodeJS.Signals = 'SIGTERM'): boolean {
+    const spawnedProcess = this.processes.get(processName)
+    if (!spawnedProcess || !spawnedProcess.isRunning) {
+      return false
+    }
+
+    spawnedProcess.process.kill(signal)
+    return true
+  }
+
+  async waitForProcess(processName: string): Promise<number | null> {
+    const spawnedProcess = this.processes.get(processName)
+    if (!spawnedProcess) {
+      throw new Error(`Process '${processName}' not found`)
+    }
+
+    return new Promise(resolve => {
+      if (!spawnedProcess.isRunning) {
+        resolve(spawnedProcess.exitCode)
+        return
+      }
+
+      spawnedProcess.process.on('exit', (code: number | null) => resolve(code))
+    })
+  }
+
+  getProcess(processName: string): SpawnedProcess | undefined {
+    return this.processes.get(processName)
+  }
+
+  private processBufferedOutput(
+    processName: string,
+    stream: 'stdout' | 'stderr',
+    streamLogs: boolean,
+    prefixLogs: boolean,
+    captureOutput: boolean,
+    spawnedProcess: SpawnedProcess,
+  ): void {
+    const buffer = this.outputBuffers.get(processName)
+    if (!buffer) {
+      return
+    }
+
+    const lines = buffer[stream].split('\n')
+    buffer[stream] = lines.pop() || ''
+
+    for (const line of lines) {
+      if (captureOutput) {
+        spawnedProcess.output[stream].push(`${line}\n`)
+      }
+
+      if (streamLogs) {
+        const prefix = prefixLogs ? `[${processName}] ` : ''
+        if (stream === 'stdout') {
+          console.log(`${prefix}${line}`)
+        } else {
+          console.error(`${prefix}${line}`)
+        }
+      }
+
+      this.emit(stream, { processName, data: `${line}\n` })
+    }
+  }
+
+  private setupProcessListeners(
+    spawnedProcess: SpawnedProcess,
+    options: {
+      streamLogs: boolean
+      prefixLogs: boolean
+      captureOutput: boolean
+      stdioConfig: string | string[]
+    },
+  ): void {
+    const { streamLogs, prefixLogs, captureOutput, stdioConfig } = options
+    const { process: childProcess, name } = spawnedProcess
+
+    if (stdioConfig === 'pipe') {
+      childProcess.stdout?.on('data', (data: Buffer) => {
+        const buffer = this.outputBuffers.get(name)
+        if (!buffer) {
+          return
+        }
+
+        buffer.stdout += data.toString()
+        this.processBufferedOutput(name, 'stdout', streamLogs, prefixLogs, captureOutput, spawnedProcess)
+      })
+
+      childProcess.stderr?.on('data', (data: Buffer) => {
+        const buffer = this.outputBuffers.get(name)
+        if (!buffer) {
+          return
+        }
+
+        buffer.stderr += data.toString()
+        this.processBufferedOutput(name, 'stderr', streamLogs, prefixLogs, captureOutput, spawnedProcess)
+      })
+    }
+
+    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)
+        }
+      }
+
+      spawnedProcess.isRunning = false
+      spawnedProcess.exitCode = code
+      spawnedProcess.endTime = new Date()
+      this.emit('exit', { processName: name, code })
+    })
+
+    childProcess.on('error', (error: Error) => {
+      spawnedProcess.isRunning = false
+      spawnedProcess.endTime = new Date()
+
+      if (streamLogs) {
+        const prefix = prefixLogs ? `[${name}] ` : ''
+        console.error(`${prefix}ERROR: ${error.message}`)
+      }
+
+      this.emit('error', { processName: name, error })
+    })
+  }
+}
+
+const globalForTaskSpawner = global as unknown as {
+  taskSpawner: TaskSpawner | undefined
+}
+
+export const taskSpawner = globalForTaskSpawner.taskSpawner ?? new TaskSpawner()
+
+if (!globalForTaskSpawner.taskSpawner) {
+  globalForTaskSpawner.taskSpawner = taskSpawner
+}
+
+export const spawnTask = (command: string, args: string[] = [], options: SpawnerOptions = {}) =>
+  taskSpawner.spawn(command, args, options)
+
+export const killTask = (processName: string, signal?: NodeJS.Signals) => taskSpawner.killProcess(processName, signal)
+
+export const waitForTask = (processName: string) => taskSpawner.waitForProcess(processName)

package/templates/default/src/lib/template-sync-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function shouldExcludeTemplatePath(relativePath: string): boolean;
+export declare function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile: boolean, legacyEnvironmentsDirExists: boolean): boolean;
+export declare function getAutomationFeaturesDir(baseDir: string): string;
+export declare function getAutomationLocatorsDir(baseDir: string): string;
+export declare function getAutomationLocatorMapPath(baseDir: string): string;
+export declare function extractModulePathFromAutomationFile(filePath: string, baseDir: string, automationSubdir: 'features' | 'locators'): string;
+//# sourceMappingURL=template-sync-utils.d.ts.map

package/templates/default/src/lib/template-sync-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-sync-utils.d.ts","sourceRoot":"","sources":["template-sync-utils.ts"],"names":[],"mappings":"AAUA,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAgBvE;AAED,wBAAgB,qCAAqC,CACnD,yBAAyB,EAAE,OAAO,EAClC,2BAA2B,EAAE,OAAO,GACnC,OAAO,CAET;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,UAAU,GAAG,UAAU,GACxC,MAAM,CAWR"}

package/templates/default/src/lib/template-sync-utils.js

@@ -0,0 +1,47 @@
+import { join, relative } from 'path';
+const EXCLUDED_DIRS = new Set(['node_modules', '.next', '.git', 'dist']);
+const EXCLUDED_EXTENSIONS = new Set(['.db', '.sqlite', '.sqlite3', '.tsbuildinfo']);
+const EXCLUDED_PATH_PREFIXES = ['automation/reports/'];
+function toPosixPath(value) {
+    return value.replace(/\\/g, '/');
+}
+export function shouldExcludeTemplatePath(relativePath) {
+    const normalizedPath = toPosixPath(relativePath);
+    const parts = normalizedPath.split('/');
+    if (parts.some(part => EXCLUDED_DIRS.has(part)))
+        return true;
+    if (EXCLUDED_PATH_PREFIXES.some(prefix => normalizedPath.startsWith(prefix)))
+        return true;
+    const ext = normalizedPath.endsWith('.sqlite3')
+        ? '.sqlite3'
+        : normalizedPath.endsWith('.sqlite')
+            ? '.sqlite'
+            : normalizedPath.endsWith('.tsbuildinfo')
+                ? '.tsbuildinfo'
+                : normalizedPath.slice(normalizedPath.lastIndexOf('.'));
+    return EXCLUDED_EXTENSIONS.has(ext);
+}
+export function shouldBackfillLegacyEnvironmentConfig(targetHasEnvironmentsFile, legacyEnvironmentsDirExists) {
+    return !targetHasEnvironmentsFile && legacyEnvironmentsDirExists;
+}
+export function getAutomationFeaturesDir(baseDir) {
+    return join(baseDir, 'automation', 'features');
+}
+export function getAutomationLocatorsDir(baseDir) {
+    return join(baseDir, 'automation', 'locators');
+}
+export function getAutomationLocatorMapPath(baseDir) {
+    return join(baseDir, 'automation', 'mapping', 'locator-map.json');
+}
+export function extractModulePathFromAutomationFile(filePath, baseDir, automationSubdir) {
+    const automationBaseDir = automationSubdir === 'features' ? getAutomationFeaturesDir(baseDir) : getAutomationLocatorsDir(baseDir);
+    const normalizedBaseDir = toPosixPath(automationBaseDir).replace(/\/$/, '');
+    const normalizedFilePath = toPosixPath(filePath);
+    const relativePath = normalizedFilePath.startsWith(`${normalizedBaseDir}/`)
+        ? normalizedFilePath.slice(normalizedBaseDir.length + 1)
+        : toPosixPath(relative(automationBaseDir, filePath));
+    const pathParts = relativePath.split('/').filter(part => part && part !== '');
+    const moduleParts = pathParts.slice(0, -1);
+    return moduleParts.length > 0 ? `/${moduleParts.join('/')}` : '/';
+}
+//# sourceMappingURL=template-sync-utils.js.map