@sun-asterisk/sungen 2.2.2 → 2.3.0

package/src/generators/test-generator/patterns/assertion-patterns.ts

@@ -6,6 +6,30 @@ import { StepPattern, StepTemplateData } from './types';
  * Uses template engine for framework-agnostic code generation
  */
 export const assertionPatterns: StepPattern[] = [
+  // Browser alert text assertion: "see [Are you sure?] alert"
+  {
+    name: 'alert-text-assertion',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('see') || step.text.includes('sees')) &&
+      step.elementType === 'alert' &&
+      !!step.selectorRef,
+    resolver: (step, context): StepTemplateData => {
+      let dataValue = step.selectorRef || '';
+      if (step.dataRef) {
+        try {
+          dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+        } catch {
+          dataValue = `\${${step.dataRef}}`;
+        }
+      }
+      return {
+        templateName: 'alert-text-assertion',
+        data: { dataValue, stepCounter: context.stepCounter },
+        comment: `Assert browser alert contains "${step.selectorRef}"`,
+      };
+    },
+    priority: 21,
+  },
   // Column cell assertion: "see [Department] column 1 with {{value}}" -> check table cell text
   {
     name: 'column-cell-assertion',
@@ -218,6 +242,7 @@ export const assertionPatterns: StepPattern[] = [
   // Pattern: Then User see [error] message with {{fail_message}}
   // If selector YAML has empty value, uses variable-only matching
   // If selector has value, combines both (static text + variable)
+  // Input types → toHaveValue, everything else → toHaveText
   {
     name: 'see-with-variable',
     matcher: (step: ParsedStep) =>
@@ -227,6 +252,12 @@ export const assertionPatterns: StepPattern[] = [
       !!step.dataRef &&
       step.text.includes('with'),
     generator: (step, context) => {
+      // Input element types use toHaveValue instead of toHaveText
+      const INPUT_TYPES = new Set([
+        'field', 'textarea', 'search', 'dropdown', 'slider', 'date-picker',
+        'input', 'textbox', 'editor', 'select', 'combobox',
+      ]);
+
       // Resolve data variable value
       let dataValue: string;
       try {
@@ -235,19 +266,55 @@ export const assertionPatterns: StepPattern[] = [
         dataValue = `\${${step.dataRef}}`;
       }
 
-      // Label-value pattern: "User see [X] label with {{Y}}"
-      // Uses regex getByText to match container with both label and value text
+      // Resolve selector from YAML with feature context
+      let resolved: any = {};
+      try {
+        resolved = context.selectorResolver.resolveSelector(
+          step.selectorRef!,
+          context.featureName,
+          step.elementType,
+          step.nth
+        );
+      } catch (error) {
+        // Selector not in YAML or context issue - will use variable-only
+      }
+
+      // --- Attribute assertion: toHaveAttribute ---
+      // When selector YAML has `attribute` field (e.g., attribute: 'src', 'href')
+      if (resolved.attribute) {
+        const code = context.templateEngine.renderStep('attribute-assertion', {
+          ...resolved,
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} ${resolved.attribute} matches ${step.dataRef}`,
+        };
+      }
+
+      // --- Input types: toHaveValue ---
+      if (step.elementType && INPUT_TYPES.has(step.elementType)) {
+        const code = context.templateEngine.renderStep('have-value-assertion', {
+          ...resolved,
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} has value ${step.dataRef}`,
+        };
+      }
+
+      // --- Label-value pattern: "User see [X] label with {{Y}}" ---
       if (step.elementType === 'label' && step.dataRef) {
-        // Check if selector override has empty value — if so, omit label from regex
         let label: string | undefined = step.selectorRef;
         try {
-          const resolved = context.selectorResolver.resolveSelector(
+          const labelResolved = context.selectorResolver.resolveSelector(
             step.selectorRef!,
             context.featureName,
             step.elementType,
             step.nth
           );
-          if (resolved.value !== undefined && resolved.value.trim() === '') {
+          if (labelResolved.value !== undefined && labelResolved.value.trim() === '') {
             label = undefined;
           }
         } catch {
@@ -264,93 +331,67 @@ export const assertionPatterns: StepPattern[] = [
         };
       }
 
-      // Resolve selector from YAML with feature context
-      let resolved: any = {};
-      try {
-        resolved = context.selectorResolver.resolveSelector(
-          step.selectorRef!,
-          context.featureName,
-          step.elementType,
-          step.nth
-        );
-      } catch (error) {
-        // Selector not in YAML or context issue - will use variable-only
-      }
-
-      const escapedVariable = dataValue.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-
-      // Check if it's a locator strategy - use locator with filter
-      if (resolved.strategy === 'locator') {
-        const code = context.templateEngine.renderStep('visible-with-locator-variable-assertion', {
-          ...resolved,
+      // --- Dialog role: check heading inside dialog ---
+      if (resolved.strategy === 'role' && resolved.role === 'dialog') {
+        const code = context.templateEngine.renderStep('visible-dialog-heading-assertion', {
           dataValue,
-          nth: resolved.nth,
         });
         return {
           code,
-          comment: `Assert ${step.selectorRef} with value ${step.dataRef}`,
+          comment: `Assert ${step.selectorRef} dialog with heading ${step.dataRef}`,
         };
       }
 
-      // Check if it's a role-based selector with data
-      if (resolved.strategy === 'role' && resolved.role) {
-        // Dialog role: check heading inside dialog instead of filter on full text content
-        if (resolved.role === 'dialog') {
-          const code = context.templateEngine.renderStep('visible-dialog-heading-assertion', {
-            dataValue,
-          });
-          return {
-            code,
-            comment: `Assert ${step.selectorRef} dialog with heading ${step.dataRef}`,
-          };
-        }
-
+      // --- Image role: images have no text, use name ---
+      if (resolved.strategy === 'role' && resolved.role === 'img') {
         const hasName = resolved.name && resolved.name.trim();
-        // For img role: images have no text content, so put dataValue in name instead of filter
-        const isImgRole = resolved.role === 'img';
         const code = context.templateEngine.renderStep('visible-with-role-variable-assertion', {
           role: resolved.role,
-          name: isImgRole ? (hasName ? resolved.name : dataValue) : (hasName ? resolved.name : undefined),
-          dataValue: isImgRole ? undefined : dataValue,
+          name: hasName ? resolved.name : dataValue,
           exact: resolved.exact || false,
           nth: resolved.nth,
         });
         return {
           code,
-          comment: `Assert ${step.selectorRef} with value ${step.dataRef}`,
+          comment: `Assert ${step.selectorRef} image with name ${step.dataRef}`,
         };
       }
 
-      const selectorValue = resolved.value || '';
-
-      // If selector has a value in YAML, combine with variable
-      // Otherwise use variable-only
-      if (selectorValue && selectorValue.trim()) {
-        // Has selector value - combine both
-        const code = context.templateEngine.renderStep('visible-with-value-assertion', {
-          value: selectorValue,
-          dataValue,
-          dataRef: step.dataRef,
-          nth: resolved.nth,
-          exact: resolved.exact || false,
+      // --- Everything else: toHaveText (exact full match) ---
+      // Locator strategy
+      if (resolved.strategy === 'locator') {
+        const code = context.templateEngine.renderStep('have-text-assertion', {
+          ...resolved,
+          expectedText: dataValue,
         });
         return {
           code,
-          comment: `Assert ${step.selectorRef} with value ${step.dataRef}`,
+          comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
         };
-      } else {
-        // Empty selector - use variable only
-        const code = context.templateEngine.renderStep('visible-with-variable-assertion', {
-          selectorRef: step.selectorRef,
-          selectorValue: resolved.value || '',
-          dataValue,
-          nth: resolved.nth,
+      }
+
+      // Role-based selector
+      if (resolved.strategy === 'role' && resolved.role) {
+        const hasName = resolved.name && resolved.name.trim();
+        const code = context.templateEngine.renderStep('have-text-assertion', {
+          ...resolved,
+          expectedText: dataValue,
         });
         return {
           code,
-          comment: `Assert ${step.selectorRef} visible with ${step.dataRef}`,
+          comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
         };
       }
+
+      // Text/placeholder/testid/other strategies
+      const code = context.templateEngine.renderStep('have-text-assertion', {
+        ...resolved,
+        expectedText: dataValue,
+      });
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+      };
     },
     priority: 13,
   },

package/src/generators/test-generator/patterns/index.ts

@@ -72,6 +72,14 @@ export class PatternRegistry {
     // Prefer resolver (framework-agnostic) over generator (legacy)
     if (pattern.resolver) {
       const resolved = pattern.resolver(step, context);
+
+      // Auto-inject parent scoping if step has parentRef
+      if (step.parentRef && step.parentType) {
+        resolved.data.parentLocator = PatternRegistry.resolveParentLocator(
+          step.parentRef, step.parentType, context
+        );
+      }
+
       const code = context.templateEngine.renderStep(resolved.templateName, resolved.data);
       return {
         code,
@@ -86,6 +94,39 @@ export class PatternRegistry {
     return null;
   }
 
+  /**
+   * Resolve parent scoping to a Playwright locator string.
+   * Tries YAML lookup first, falls back to auto-infer from parentType.
+   *
+   * Parent type → Playwright role:
+   *   table → 'table', list → 'list', section → 'region',
+   *   dialog → 'dialog', form → 'form'
+   */
+  private static resolveParentLocator(
+    parentRef: string, parentType: string, context: PatternContext
+  ): string {
+    // Try resolving from selectors YAML
+    try {
+      const resolved = context.selectorResolver.resolveSelector(
+        parentRef, context.featureName, parentType, 0
+      );
+      return context.renderLocator(resolved);
+    } catch {
+      // Fallback: auto-infer from parentType + parentRef as accessible name
+    }
+
+    const roleMap: Record<string, string> = {
+      table: 'table',
+      list: 'list',
+      section: 'region',
+      dialog: 'dialog',
+      form: 'form',
+    };
+    const role = roleMap[parentType] || parentType;
+    const escapedName = parentRef.replace(/'/g, "\\'");
+    return `page.getByRole('${role}', { name: '${escapedName}' })`;
+  }
+
   /**
    * Check if step matches a pattern matcher
    */

package/src/generators/test-generator/patterns/interaction-patterns.ts

@@ -27,9 +27,66 @@ function elementKeywordToRole(text: string): string | null {
 }
 
 /**
- * Interaction patterns: click, hover, press, wait
+ * Interaction patterns: click, hover, press, wait, alert
  */
 export const interactionPatterns: StepPattern[] = [
+  // === Browser Alert (system dialog) patterns ===
+  // These must appear BEFORE the click that triggers the alert in Gherkin:
+  //   When User click [OK] alert       ← registers page.once('dialog', ...)
+  //   And User click [Delete] button   ← triggers the alert
+  {
+    name: 'alert-accept',
+    matcher: (step: ParsedStep) =>
+      step.elementType === 'alert' &&
+      (step.text.includes('click') || step.text.includes('clicks')) &&
+      !step.dataRef &&
+      !!(step.selectorRef && /^(ok|accept|yes|confirm)$/i.test(step.selectorRef)),
+    resolver: (step, context) => {
+      return {
+        templateName: 'alert-accept-action',
+        data: {},
+        comment: `Accept browser alert`,
+      };
+    },
+    priority: 20,
+  },
+  {
+    name: 'alert-dismiss',
+    matcher: (step: ParsedStep) =>
+      step.elementType === 'alert' &&
+      (step.text.includes('click') || step.text.includes('clicks')) &&
+      !step.dataRef &&
+      !!(step.selectorRef && /^(cancel|dismiss|no)$/i.test(step.selectorRef)),
+    resolver: (step, context) => {
+      return {
+        templateName: 'alert-dismiss-action',
+        data: {},
+        comment: `Dismiss browser alert`,
+      };
+    },
+    priority: 20,
+  },
+  {
+    name: 'alert-fill',
+    matcher: (step: ParsedStep) =>
+      step.elementType === 'alert' &&
+      step.text.includes('fill') &&
+      !!step.dataRef,
+    resolver: (step, context) => {
+      let fillValue: string;
+      try {
+        fillValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch {
+        fillValue = `\${${step.dataRef}}`;
+      }
+      return {
+        templateName: 'alert-fill-action',
+        data: { fillValue },
+        comment: `Fill browser prompt with ${step.dataRef}`,
+      };
+    },
+    priority: 20,
+  },
   {
     name: 'unknown-element-action',
     matcher: (step: ParsedStep) => {

package/src/generators/test-generator/patterns/table-patterns.ts

@@ -6,11 +6,12 @@
 import { StepPattern } from './types';
 
 export const tablePatterns: StepPattern[] = [
-  // "User see [Users] table has {{count}} rows" — must have "rows" AFTER {{data}}
+  // "User see [Users] table with {{count}} rows" (preferred)
+  // Also accepts: "User see [Users] table has {{count}} rows" (backward compat)
   {
     name: 'table-row-count',
     matcher: (step) => {
-      return /\btable\s+has\b/i.test(step.text) &&
+      return /\btable\s+(?:has|with)\b/i.test(step.text) &&
              /\}\}\s*rows?\b/i.test(step.text) &&
              !!step.dataRef;
     },
@@ -29,7 +30,8 @@ export const tablePatterns: StepPattern[] = [
     priority: 16,
   },
 
-  // "User see [Users] table has [Email] column"
+  // "User see [Users] table has [Email] column" (backward compat)
+  // Preferred: "User see [Email] column in [Users] table" (parent scoping)
   {
     name: 'table-column-exists',
     matcher: (step) => {
@@ -152,11 +154,12 @@ export const tablePatterns: StepPattern[] = [
     priority: 17,
   },
 
-  // "User see [Users] table has row with {{name}}"
+  // "User see [Users] table row with {{name}}" (preferred)
+  // Also accepts: "User see [Users] table has row with {{name}}" (backward compat)
   {
     name: 'table-row-exists',
     matcher: (step) => {
-      return /\btable\s+has\s+row\s+with\b/i.test(step.text) && !!step.dataRef;
+      return /\btable\s+(?:has\s+)?row\s+with\b/i.test(step.text) && !!step.dataRef;
     },
     resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(

package/src/generators/test-generator/utils/selector-resolver.ts

@@ -211,6 +211,13 @@ export class SelectorResolver {
       'heading': () => ({ strategy: 'role', role: 'heading', name: label, value: 'heading' }),
       'list': () => ({ strategy: 'role', role: 'list', name: label, value: 'list' }),
       'listitem': () => ({ strategy: 'role', role: 'listitem', value: 'listitem' }),
+      'searchbox': () => ({ strategy: 'role', role: 'searchbox', name: label, value: 'searchbox' }),
+      'option': () => ({ strategy: 'role', role: 'option', name: label, value: 'option' }),
+      'slider': () => ({ strategy: 'role', role: 'slider', name: label, value: 'slider' }),
+      'switch': () => ({ strategy: 'role', role: 'switch', name: label, value: 'switch' }),
+      'tab': () => ({ strategy: 'role', role: 'tab', name: label, value: 'tab' }),
+      'dialog': () => ({ strategy: 'role', role: 'dialog', name: label, value: 'dialog' }),
+      'alertdialog': () => ({ strategy: 'role', role: 'alertdialog', name: label, value: 'alertdialog' }),
     };
 
     const factory = strategyMap[normalized];
@@ -247,6 +254,15 @@ export class SelectorResolver {
       'textbox': 'field',
       'textarea': 'field',
       'editor': 'field',
+      // Search alias → searchbox role
+      'search': 'searchbox',
+      // Toggle alias → switch role
+      'toggle': 'switch',
+      // Alert alias → alertdialog role
+      'alert': 'alertdialog',
+      // Modal/drawer alias → dialog role
+      'modal': 'dialog',
+      'drawer': 'dialog',
     };
     return aliasMap[elementType] || elementType;
   }

package/src/orchestrator/ai-rules-updater.ts

@@ -0,0 +1,139 @@
+/**
+ * AI Rules Updater
+ * Updates AI rules, commands, and skills from bundled templates.
+ * Used by `sungen update` command.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// File mapping: [templateFile, outputPath]
+// Shared with project-initializer.ts
+export const AI_RULES_FILE_MAPPING: [string, string][] = [
+  // Config
+  ['claude-config.md', 'CLAUDE.md'],
+  ['copilot-config.md', '.github/copilot-instructions.md'],
+
+  // Commands — Claude Code
+  ['claude-cmd-add-screen.md', '.claude/commands/sungen/add-screen.md'],
+  ['claude-cmd-make-tc.md', '.claude/commands/sungen/make-tc.md'],
+  ['claude-cmd-make-test.md', '.claude/commands/sungen/make-test.md'],
+
+  // Commands — GitHub Copilot
+  ['copilot-cmd-add-screen.md', '.github/prompts/sungen-add-screen.prompt.md'],
+  ['copilot-cmd-make-tc.md', '.github/prompts/sungen-make-tc.prompt.md'],
+  ['copilot-cmd-make-test.md', '.github/prompts/sungen-make-test.prompt.md'],
+
+  // Skills — Claude Code
+  ['claude-skill-gherkin-syntax.md', '.claude/skills/sungen-gherkin-syntax/SKILL.md'],
+  ['claude-skill-selector-keys.md', '.claude/skills/sungen-selector-keys/SKILL.md'],
+  ['claude-skill-error-mapping.md', '.claude/skills/sungen-error-mapping/SKILL.md'],
+  ['claude-skill-tc-generation.md', '.claude/skills/sungen-tc-generation/SKILL.md'],
+  ['claude-skill-selector-fix.md', '.claude/skills/sungen-selector-fix/SKILL.md'],
+
+  // Skills — GitHub Copilot
+  ['github-skill-sungen-gherkin-syntax.md', '.github/skills/sungen-gherkin-syntax/SKILL.md'],
+  ['github-skill-sungen-selector-keys.md', '.github/skills/sungen-selector-keys/SKILL.md'],
+  ['github-skill-sungen-error-mapping.md', '.github/skills/sungen-error-mapping/SKILL.md'],
+  ['github-skill-sungen-tc-generation.md', '.github/skills/sungen-tc-generation/SKILL.md'],
+  ['github-skill-sungen-selector-fix.md', '.github/skills/sungen-selector-fix/SKILL.md'],
+];
+
+export class AIRulesUpdater {
+  private cwd: string;
+  private aiTemplateDir: string;
+
+  constructor(cwd: string) {
+    this.cwd = cwd;
+    this.aiTemplateDir = path.join(__dirname, 'templates', 'ai-instructions');
+  }
+
+  async update(dryRun: boolean): Promise<void> {
+    console.log('🔄 Updating AI rules, commands, and skills...\n');
+
+    const updated: string[] = [];
+    const created: string[] = [];
+    const unchanged: string[] = [];
+    const missing: string[] = [];
+
+    for (const [templateFile, outputRelPath] of AI_RULES_FILE_MAPPING) {
+      const templatePath = path.join(this.aiTemplateDir, templateFile);
+      const outputPath = path.join(this.cwd, outputRelPath);
+
+      if (!fs.existsSync(templatePath)) {
+        missing.push(templateFile);
+        continue;
+      }
+
+      const newContent = fs.readFileSync(templatePath, 'utf-8');
+
+      if (fs.existsSync(outputPath)) {
+        const currentContent = fs.readFileSync(outputPath, 'utf-8');
+        if (currentContent === newContent) {
+          unchanged.push(outputRelPath);
+          continue;
+        }
+
+        if (!dryRun) {
+          fs.writeFileSync(outputPath, newContent, 'utf-8');
+        }
+        updated.push(outputRelPath);
+      } else {
+        if (!dryRun) {
+          const outputDir = path.dirname(outputPath);
+          if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+          }
+          fs.writeFileSync(outputPath, newContent, 'utf-8');
+        }
+        created.push(outputRelPath);
+      }
+    }
+
+    // Print results
+    if (dryRun) {
+      console.log('📋 Dry run — no files changed\n');
+    }
+
+    if (updated.length > 0) {
+      console.log(`✏️  Updated (${updated.length}):`);
+      for (const f of updated) {
+        console.log(`   ${f}`);
+      }
+      console.log();
+    }
+
+    if (created.length > 0) {
+      console.log(`✨ Created (${created.length}):`);
+      for (const f of created) {
+        console.log(`   ${f}`);
+      }
+      console.log();
+    }
+
+    if (unchanged.length > 0) {
+      console.log(`✅ Already up to date (${unchanged.length}):`);
+      for (const f of unchanged) {
+        console.log(`   ${f}`);
+      }
+      console.log();
+    }
+
+    if (missing.length > 0) {
+      console.log(`⚠️  Template not found (${missing.length}):`);
+      for (const f of missing) {
+        console.log(`   ${f}`);
+      }
+      console.log();
+    }
+
+    const totalChanges = updated.length + created.length;
+    if (totalChanges === 0) {
+      console.log('All AI rules are up to date. No changes needed.');
+    } else if (dryRun) {
+      console.log(`${totalChanges} file(s) would be changed. Run without --dry-run to apply.`);
+    } else {
+      console.log(`${totalChanges} file(s) updated successfully.`);
+    }
+  }
+}

package/src/orchestrator/project-initializer.ts

@@ -6,6 +6,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
+import { AI_RULES_FILE_MAPPING } from './ai-rules-updater';
 
 export class ProjectInitializer {
   private baseCwd: string;
@@ -250,38 +251,7 @@ export class ProjectInitializer {
   private createAIRules(): void {
     const aiTemplateDir = path.join(__dirname, 'templates', 'ai-instructions');
 
-    // File mapping: [templateFile, outputPath]
-    const fileMapping: [string, string][] = [
-      // Config
-      ['claude-config.md', 'CLAUDE.md'],
-      ['copilot-config.md', '.github/copilot-instructions.md'],
-
-      // Commands — Claude Code
-      ['claude-cmd-add-screen.md', '.claude/commands/sungen/add-screen.md'],
-      ['claude-cmd-make-tc.md', '.claude/commands/sungen/make-tc.md'],
-      ['claude-cmd-make-test.md', '.claude/commands/sungen/make-test.md'],
-
-      // Commands — GitHub Copilot
-      ['copilot-cmd-add-screen.md', '.github/prompts/sungen-add-screen.prompt.md'],
-      ['copilot-cmd-make-tc.md', '.github/prompts/sungen-make-tc.prompt.md'],
-      ['copilot-cmd-make-test.md', '.github/prompts/sungen-make-test.prompt.md'],
-
-      // Skills — Claude Code
-      ['claude-skill-gherkin-syntax.md', '.claude/skills/sungen-gherkin-syntax/SKILL.md'],
-      ['claude-skill-selector-keys.md', '.claude/skills/sungen-selector-keys/SKILL.md'],
-      ['claude-skill-error-mapping.md', '.claude/skills/sungen-error-mapping/SKILL.md'],
-      ['claude-skill-tc-generation.md', '.claude/skills/sungen-tc-generation/SKILL.md'],
-      ['claude-skill-selector-fix.md', '.claude/skills/sungen-selector-fix/SKILL.md'],
-
-      // Skills — GitHub Copilot (separate copies with Copilot-friendly descriptions)
-      ['github-skill-sungen-gherkin-syntax.md', '.github/skills/sungen-gherkin-syntax/SKILL.md'],
-      ['github-skill-sungen-selector-keys.md', '.github/skills/sungen-selector-keys/SKILL.md'],
-      ['github-skill-sungen-error-mapping.md', '.github/skills/sungen-error-mapping/SKILL.md'],
-      ['github-skill-sungen-tc-generation.md', '.github/skills/sungen-tc-generation/SKILL.md'],
-      ['github-skill-sungen-selector-fix.md', '.github/skills/sungen-selector-fix/SKILL.md'],
-    ];
-
-    for (const [templateFile, outputRelPath] of fileMapping) {
+    for (const [templateFile, outputRelPath] of AI_RULES_FILE_MAPPING) {
       const outputPath = path.join(this.cwd, outputRelPath);
 
       if (fs.existsSync(outputPath)) {