testchimp-runner-core 0.0.16 → 0.0.18

package/src/execution-service.ts

@@ -27,6 +27,7 @@ export class ExecutionService {
   private creditUsageService: CreditUsageService;
   private maxConcurrentExecutions: number;
   private activeExecutions: Set<Promise<any>> = new Set();
+  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
 
   constructor(authConfig?: AuthConfig, backendUrl?: string, maxConcurrentExecutions: number = 10) {
     this.playwrightService = new PlaywrightService();
@@ -35,6 +36,30 @@ export class ExecutionService {
     this.maxConcurrentExecutions = maxConcurrentExecutions;
   }
 
+  /**
+   * Set a logger callback for capturing execution logs
+   */
+  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
+    this.logger = logger;
+  }
+
+  /**
+   * Log a message using the configured logger or console
+   */
+  private log(message: string, level: 'log' | 'error' | 'warn' = 'log'): void {
+    if (this.logger) {
+      this.logger(message, level);
+    } else {
+      if (level === 'error') {
+        console.error(message);
+      } else if (level === 'warn') {
+        console.warn(message);
+      } else {
+        console.log(message);
+      }
+    }
+  }
+
   /**
    * Initialize the execution service
    */
@@ -189,7 +214,7 @@ export class ExecutionService {
     const totalAttempts = deflakeRunCount + 1; // Original run + deflake attempts
     let lastError: Error | null = null;
     
-    console.log(`runExactly: deflake_run_count = ${request.deflake_run_count}, totalAttempts = ${totalAttempts}`);
+    this.log(`runExactly: deflake_run_count = ${request.deflake_run_count}, totalAttempts = ${totalAttempts}`);
 
     // Script content should be provided by the caller (TestChimpService)
     // The TestChimpService handles file reading through the appropriate FileHandler
@@ -198,7 +223,7 @@ export class ExecutionService {
     }
 
     for (let attempt = 1; attempt <= totalAttempts; attempt++) {
-      console.log(`Attempting deflake run ${attempt}/${totalAttempts}`);
+      this.log(`Attempting deflake run ${attempt}/${totalAttempts}`);
       const { browser, context, page } = await this.initializeBrowser(request.playwrightConfig, request.headless, request.playwrightConfigFilePath);
 
       try {
@@ -215,7 +240,7 @@ export class ExecutionService {
         };
       } catch (error) {
         lastError = error instanceof Error ? error : new Error('Script execution failed');
-        console.log(`Initial run failed: ${lastError.message}`);
+        this.log(`Initial run failed: ${lastError.message}`);
         
         try {
           await browser.close();
@@ -225,7 +250,7 @@ export class ExecutionService {
 
         // If this is not the last attempt, continue to next attempt
         if (attempt < totalAttempts) {
-          console.log(`Deflaking attempt ${attempt} failed, trying again... (${attempt + 1}/${totalAttempts})`);
+          this.log(`Deflaking attempt ${attempt} failed, trying again... (${attempt + 1}/${totalAttempts})`);
           continue;
         }
       }
@@ -250,7 +275,7 @@ export class ExecutionService {
     }
 
     // First, try runExactly (which includes deflaking if configured)
-    console.log('Attempting runExactly first (with deflaking if configured)...');
+    this.log('Attempting runExactly first (with deflaking if configured)...');
     const runExactlyResult = await this.runExactly(request, startTime, model);
     
     // If runExactly succeeded, return that result
@@ -259,18 +284,18 @@ export class ExecutionService {
     }
 
     // runExactly failed, start AI repair
-    console.log('runExactly failed, starting AI repair process...');
+    this.log('runExactly failed, starting AI repair process...');
 
     try {
         
         // Start browser initialization and script parsing in parallel for faster startup
-        console.log('Initializing repair browser and parsing script...');
+        this.log('Initializing repair browser and parsing script...');
         const [steps, { browser: repairBrowser, context: repairContext, page: repairPage }] = await Promise.all([
           this.parseScriptIntoSteps(request.script, model),
           this.initializeBrowser(request.playwrightConfig, request.headless, request.playwrightConfigFilePath) // Use request.headless (defaults to false/headed)
         ]);
         
-        console.log('Starting AI repair with parsed steps...');
+        this.log('Starting AI repair with parsed steps...');
         const updatedSteps = await this.repairStepsWithAI(steps, repairPage, repairFlexibility, model);
         
         // Always generate the updated script
@@ -283,13 +308,13 @@ export class ExecutionService {
         const hasSuccessfulRepairs = updatedSteps.some(step => step.success);
         
         // Debug: Log step success status
-        console.log('Step success status:', updatedSteps.map((step, index) => `Step ${index + 1}: ${step.success ? 'SUCCESS' : 'FAILED'}`));
-        console.log('All steps successful:', allStepsSuccessful);
-        console.log('Has successful repairs:', hasSuccessfulRepairs);
+        this.log('Step success status: ' + updatedSteps.map((step, index) => `Step ${index + 1}: ${step.success ? 'SUCCESS' : 'FAILED'}`).join(', '));
+        this.log(`All steps successful: ${allStepsSuccessful}`);
+        this.log(`Has successful repairs: ${hasSuccessfulRepairs}`);
         
         // Debug: Log individual step details
         updatedSteps.forEach((step, index) => {
-          console.log(`Step ${index + 1} details: success=${step.success}, description="${step.description}"`);
+          this.log(`Step ${index + 1} details: success=${step.success}, description="${step.description}"`);
         });
         
         // Update file if we have any successful repairs (partial or complete)
@@ -345,14 +370,14 @@ export class ExecutionService {
   private async parseScriptIntoSteps(script: string, model: string): Promise<(ScriptStep & { success?: boolean; error?: string })[]> {
     // First try LLM-based parsing
     try {
-      console.log('Attempting LLM-based script parsing...');
+      this.log('Attempting LLM-based script parsing...');
       const result = await this.llmFacade.parseScriptIntoSteps(script, model);
-      console.log('LLM parsing successful, got', result.length, 'steps');
+      this.log(`LLM parsing successful, got ${result.length} steps`);
       return result;
     } catch (error) {
-      console.log('LLM parsing failed, falling back to code parsing:', error);
+      this.log(`LLM parsing failed, falling back to code parsing: ${error}`);
       const fallbackResult = this.parseScriptIntoStepsFallback(script);
-      console.log('Fallback parsing successful, got', fallbackResult.length, 'steps');
+      this.log(`Fallback parsing successful, got ${fallbackResult.length} steps`);
       return fallbackResult;
     }
   }
@@ -428,26 +453,26 @@ export class ExecutionService {
     let i = 0;
     while (i < updatedSteps.length) {
       const step = updatedSteps[i];
-      console.log(`Loop iteration: i=${i}, step description="${step.description}", total steps=${updatedSteps.length}`);
+      this.log(`Loop iteration: i=${i}, step description="${step.description}", total steps=${updatedSteps.length}`);
       
       try {
         // Try to execute the step directly without context replay
-        console.log(`Attempting Step ${i + 1}: ${step.description}`);
-        console.log(`  Code: ${step.code}`);
+        this.log(`Attempting Step ${i + 1}: ${step.description}`);
+        this.log(`  Code: ${step.code}`);
         await this.executeStepCode(step.code, page);
         step.success = true;
-        console.log(`Step ${i + 1} executed successfully: ${step.description}`);
-        console.log(`Step ${i + 1} success status set to: ${step.success}`);
+        this.log(`Step ${i + 1} executed successfully: ${step.description}`);
+        this.log(`Step ${i + 1} success status set to: ${step.success}`);
         
         // Add this step's code to the execution context for future steps (for variable tracking)
         executionContext += step.code + '\n';
         i++; // Move to next step
       } catch (error) {
-        console.log(`Step ${i + 1} failed: ${step.description}`);
-        console.log(`  Failed code: ${step.code}`);
-        console.log(`  Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        this.log(`Step ${i + 1} failed: ${step.description}`);
+        this.log(`  Failed code: ${step.code}`);
+        this.log(`  Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
         if (error instanceof Error && error.stack) {
-          console.log(`  Stack trace: ${error.stack}`);
+          this.log(`  Stack trace: ${error.stack}`);
         }
         step.success = false;
         step.error = this.safeSerializeError(error);
@@ -465,7 +490,7 @@ export class ExecutionService {
         const originalCode = step.code;
         
         for (let attempt = 1; attempt <= maxTries; attempt++) {
-          console.log(`Step ${i + 1} repair attempt ${attempt}/${maxTries}`);
+          this.log(`Step ${i + 1} repair attempt ${attempt}/${maxTries}`);
           
           // Get current page state for AI repair
           const pageInfo = await this.getEnhancedPageInfo(page);
@@ -488,7 +513,7 @@ export class ExecutionService {
           );
 
           if (!repairSuggestion.shouldContinue) {
-            console.log(`AI decided to stop repair at attempt ${attempt}: ${repairSuggestion.reason}`);
+            this.log(`AI decided to stop repair at attempt ${attempt}: ${repairSuggestion.reason}`);
             break;
           }
 
@@ -501,20 +526,14 @@ export class ExecutionService {
               insertAfterIndex: repairSuggestion.action.operation === StepOperation.INSERT ? i - 1 : undefined // For INSERT, insert before current step
             };
             
-            console.log(`🔧 Applying repair action:`, {
-              operation: repairAction.operation,
-              stepIndex: repairAction.stepIndex,
-              insertAfterIndex: repairAction.insertAfterIndex,
-              newStepDescription: repairAction.newStep?.description,
-              newStepCode: repairAction.newStep?.code
-            });
-            console.log(`🔧 Steps array before repair:`, updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`));
+            this.log(`🔧 Applying repair action: ${repairAction.operation} on step ${repairAction.stepIndex}`);
+            this.log(`🔧 Steps array before repair: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
             
             const result = await this.applyRepairActionInContext(repairAction, updatedSteps, i, page, executionContext, contextVariables);
             
             if (result.success) {
               repairSuccess = true;
-              console.log(`🔧 Steps array after repair:`, updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`));
+              this.log(`🔧 Steps array after repair: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
               
               // Mark the appropriate step(s) as successful based on operation type
               if (repairAction.operation === StepOperation.MODIFY) {
@@ -523,7 +542,7 @@ export class ExecutionService {
                 step.error = undefined;
                 updatedSteps[i].success = true;
                 updatedSteps[i].error = undefined;
-                console.log(`Step ${i + 1} marked as successful after MODIFY repair`);
+                this.log(`Step ${i + 1} marked as successful after MODIFY repair`);
               } else if (repairAction.operation === StepOperation.INSERT) {
                 // For INSERT: mark the newly inserted step as successful
                 const insertIndex = repairAction.insertAfterIndex !== undefined ? repairAction.insertAfterIndex + 1 : i + 1;
@@ -543,7 +562,7 @@ export class ExecutionService {
                 repairAction.operation === StepOperation.REMOVE ? 
                 `REMOVE: step at index ${repairAction.stepIndex}` :
                 repairAction.operation;
-              console.log(`Step ${i + 1} repair action ${commandInfo} executed successfully on attempt ${attempt}`);
+              this.log(`Step ${i + 1} repair action ${commandInfo} executed successfully on attempt ${attempt}`);
               
               // Update execution context based on the repair action
               if (repairAction.operation === StepOperation.MODIFY && repairAction.newStep) {
@@ -575,21 +594,21 @@ export class ExecutionService {
               // Update step index based on operation
               if (repairAction.operation === StepOperation.INSERT) {
                 // For INSERT: inserted step is already executed
-                console.log(`INSERT operation: current i=${i}, insertAfterIndex=${repairAction.insertAfterIndex}`);
-                console.log(`INSERT: Steps array length before: ${updatedSteps.length}`);
-                console.log(`INSERT: Steps before operation:`, updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`));
+                this.log(`INSERT operation: current i=${i}, insertAfterIndex=${repairAction.insertAfterIndex}`);
+                this.log(`INSERT: Steps array length before: ${updatedSteps.length}`);
+                this.log(`INSERT: Steps before operation: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
                 
                 if (repairAction.insertAfterIndex !== undefined && repairAction.insertAfterIndex < i) {
                   // If inserting before current position, current step moved down by 1
-                  console.log(`INSERT before current position: incrementing i from ${i} to ${i + 1}`);
+                  this.log(`INSERT before current position: incrementing i from ${i} to ${i + 1}`);
                   i++; // Move to the original step that was pushed to the next position
                 } else {
                   // If inserting at or after current position, stay at current step
-                  console.log(`INSERT at/after current position: keeping i at ${i}`);
+                  this.log(`INSERT at/after current position: keeping i at ${i}`);
                 }
                 
-                console.log(`INSERT: Steps array length after: ${updatedSteps.length}`);
-                console.log(`INSERT: Steps after operation:`, updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`));
+                this.log(`INSERT: Steps array length after: ${updatedSteps.length}`);
+                this.log(`INSERT: Steps after operation: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
               } else if (repairAction.operation === StepOperation.REMOVE) {
                 // For REMOVE: stay at same index since the next step moved to current position
                 // Don't increment i because the array shifted left
@@ -614,9 +633,9 @@ export class ExecutionService {
               repairSuggestion.action.operation === StepOperation.REMOVE ? 
               `REMOVE: step at index ${repairSuggestion.action.stepIndex}` :
               repairSuggestion.action.operation;
-            console.log(`Step ${i + 1} repair attempt ${attempt} failed (${commandInfo}): ${repairErrorMessage}`);
+            this.log(`Step ${i + 1} repair attempt ${attempt} failed (${commandInfo}): ${repairErrorMessage}`);
             if (repairError instanceof Error && repairError.stack) {
-              console.log(`  Repair stack trace: ${repairError.stack}`);
+              this.log(`  Repair stack trace: ${repairError.stack}`);
             }
             
             // Record this attempt in history
@@ -632,7 +651,7 @@ export class ExecutionService {
         }
 
         if (!repairSuccess) {
-          console.log(`Step ${i + 1} failed after ${maxTries} repair attempts`);
+          this.log(`Step ${i + 1} failed after ${maxTries} repair attempts`);
           break;
         }
       }
@@ -871,8 +890,8 @@ export class ExecutionService {
               success: false,
               error: undefined
             };
-            console.log(`INSERT: Inserting step at index ${insertIndex} with description "${newStep.description}"`);
-            console.log(`INSERT: Steps before insertion:`, steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`));
+            this.log(`INSERT: Inserting step at index ${insertIndex} with description "${newStep.description}"`);
+            this.log(`INSERT: Steps before insertion: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
             
             // Preserve success status of existing steps before insertion
             const successStatusMap = new Map(steps.map((step, index) => [index, { success: step.success, error: step.error }]));
@@ -893,9 +912,9 @@ export class ExecutionService {
             
             // CRITICAL FIX: Ensure the inserted step doesn't overwrite existing step data
             // The new step should only have its own description, not inherit from existing steps
-            console.log(`INSERT: Final step array after restoration:`, steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`));
+            this.log(`INSERT: Final step array after restoration: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
             
-            console.log(`INSERT: Steps after insertion:`, steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`));
+            this.log(`INSERT: Steps after insertion: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
             // Test the new step with current page state
             await this.executeStepCode(action.newStep.code, page);
             return { success: true, updatedContext: executionContext + action.newStep.code };

package/src/index.ts

@@ -91,6 +91,13 @@ export class TestChimpService {
     }
   }
 
+  /**
+   * Set logger callback for capturing execution logs
+   */
+  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
+    this.executionService.setLogger(logger);
+  }
+
   /**
    * Get current authentication configuration
    */
@@ -172,7 +179,7 @@ export class TestChimpService {
     return this.creditUsageService.reportAIRepairCredit(jobId);
   }
 
-  // Find TestChimp managed tests
+  // Find TestChimp smart/managed tests (prioritizes Smart Test detection)
   findTestChimpTests(directory: string, recursive: boolean = true): string[] {
     const fs = require('fs');
     const path = require('path');
@@ -189,7 +196,7 @@ export class TestChimpService {
           
           if (stat.isDirectory() && recursive) {
             scanDir(fullPath);
-          } else if (stat.isFile() && isTestChimpManaged(fullPath)) {
+          } else if (stat.isFile() && isTestChimpTest(fullPath)) {
             testFiles.push(fullPath);
           }
         }
@@ -198,7 +205,7 @@ export class TestChimpService {
       }
     }
     
-    function isTestChimpManaged(filePath: string): boolean {
+    function isTestChimpTest(filePath: string): boolean {
       // Check if file is a test file
       if (!filePath.match(/\.(spec|test)\.(js|ts)$/)) {
         return false;
@@ -208,15 +215,10 @@ export class TestChimpService {
         // Read file content
         const content = fs.readFileSync(filePath, 'utf8');
         
-        // Check for TestChimp markers
+        // Check for TestChimp markers - only exact comment phrases
         const testChimpMarkers = [
-          /\/\/ TestChimp:.*step/i,
-          /\/\* TestChimp:.*step \*\//i,
-          /\/\/ Step \d+:/i,
-          /\/\* Step \d+: \*\//i,
-          /testchimp.*step/i,
-          /\/\/ AI.*repair/i,
-          /\/\* AI.*repair \*\//i
+          /This is a TestChimp Smart Test/i,
+          /This is a TestChimp Managed Test/i
         ];
         
         return testChimpMarkers.some(marker => marker.test(content));

package/src/llm-facade.ts

@@ -166,6 +166,29 @@ export class LLMFacade {
     }
   }
 
+  /**
+   * Generate hashtags for semantic grouping
+   */
+  async generateHashtags(scenario: string, model: string = 'gpt-4o-mini'): Promise<string[]> {
+    console.log('Generating hashtags with LLM...');
+    
+    const request: CallLLMRequest = {
+      model,
+      system_prompt: PROMPTS.HASHTAG_GENERATION.SYSTEM,
+      user_prompt: PROMPTS.HASHTAG_GENERATION.USER(scenario)
+    };
+
+    try {
+      const response = await this.callLLM(request);
+      const hashtagResponse = JSON.parse(response) as { hashtags: string[] };
+      return hashtagResponse.hashtags || [];
+    } catch (error) {
+      console.error('Failed to generate hashtags:', error);
+      // Fallback to empty array
+      return [];
+    }
+  }
+
   /**
    * Break down scenario into steps
    */

package/src/prompts.ts

@@ -10,6 +10,13 @@ export const PROMPTS = {
     USER: (scenario: string) => `Analyze this scenario description and generate a meaningful test name:\n\n"${scenario}"\n\nInstructions:\n1. Look for ANY hints or indicators in the text that suggest what this test should be called:\n   - Explicit mentions: "Test: ...", "Scenario: ...", "Check: ...", "Verify: ..."\n   - Descriptive phrases: "...flow", "...process", "...journey", "...workflow"\n   - Action-focused terms: "login", "registration", "purchase", "messaging", "search"\n   - Business context: "user onboarding", "checkout process", "team collaboration"\n2. If you find such indicators, use them as the basis for the test name\n3. If not found, analyze the user journey and business purpose\n4. Generate a concise name under 30 characters in camelCase\n\nExamples:\n- "Test: User login and messaging flow" -> "userLoginAndMessagingFlow"\n- "Checkout process with payment" -> "checkoutProcess"\n- "User registration and email verification" -> "userRegistration"\n- "Team messaging and collaboration" -> "teamMessaging"`
   },
 
+  // Hashtag generation for semantic grouping
+  HASHTAG_GENERATION: {
+    SYSTEM: 'You are an AI assistant that generates relevant hashtags for test scenarios to enable semantic grouping across test files. Analyze the scenario description and generate 2-5 hashtags that capture the key aspects of the test such as functionality, user journey, or domain.',
+    
+    USER: (scenario: string) => `Analyze this scenario description and generate relevant hashtags for semantic grouping:\n\n"${scenario}"\n\nInstructions:\n1. Identify the main functionality being tested (e.g., #login, #checkout, #messaging)\n2. Identify the user journey type (e.g., #registration, #onboarding, #payment)\n3. Identify the domain/area (e.g., #ecommerce, #social, #admin)\n4. Identify any specific features (e.g., #search, #upload, #notification)\n5. Generate 2-5 hashtags that are:\n   - Concise and descriptive\n   - Lowercase with no spaces or special characters\n   - Relevant for grouping similar tests\n\nExamples:\n- "User login and messaging flow" -> ["#login", "#messaging", "#social"]\n- "Checkout process with payment" -> ["#checkout", "#payment", "#ecommerce"]\n- "User registration and email verification" -> ["#registration", "#verification", "#onboarding"]\n\nRespond with JSON: {"hashtags": ["#tag1", "#tag2", "#tag3"]}`
+  },
+
   // Scenario breakdown
   SCENARIO_BREAKDOWN: {
     SYSTEM: `You are an expert test automation engineer that breaks down user scenarios into precise, actionable Playwright steps.

package/src/scenario-worker-class.ts

@@ -185,6 +185,9 @@ export class ScenarioWorker {
 
       // Generate test name if not provided
       const testName = job.testName || await this.llmFacade.generateTestName(job.scenario, job.model);
+      
+      // Generate hashtags for semantic grouping
+      const hashtags = await this.llmFacade.generateHashtags(job.scenario, job.model);
 
       // Generate preferred filename
       let preferredFileName: string;
@@ -211,7 +214,7 @@ export class ScenarioWorker {
       }
 
       // Generate clean script with TestChimp comment and code
-      generatedScript = generateTestScript(testName, steps);
+      generatedScript = generateTestScript(testName, steps, undefined, hashtags);
 
       // Generate detailed execution log
       const logLines: string[] = [];

package/src/script-utils.ts

@@ -6,53 +6,69 @@
  */
 
 /**
- * TestChimp managed test comment that should be added to all generated scripts
+ * TestChimp smart test comment that should be added to all generated scripts
  */
-export const TESTCHIMP_MANAGED_COMMENT = `/*
+export const TESTCHIMP_SMART_COMMENT = `/*
 
-This is a TestChimp Managed Test.
+This is a TestChimp Smart Test.
+Version: 1.0
 
 */`;
 
 /**
- * Generates TestChimp managed test comment with optional repair advice
+ * Generates TestChimp smart test comment with optional repair advice and hashtags
  * @param repairAdvice Optional repair advice to include in the comment
+ * @param hashtags Optional hashtags for semantic grouping
  * @returns The complete comment block
  */
-export function generateTestChimpComment(repairAdvice?: string): string {
+export function generateTestChimpComment(repairAdvice?: string, hashtags?: string[]): string {
+  const hashtagString = hashtags ? hashtags.map(tag => tag.startsWith('#') ? tag : `#${tag}`).join(' ') : '';
+
   if (repairAdvice) {
     return `/*
 
-This is a TestChimp Managed Test.
+This is a TestChimp Smart Test.
+Version: 1.0
+
+${hashtagString}
 
 Repair Advice:
 ${repairAdvice}
 
 */`;
   }
-  return TESTCHIMP_MANAGED_COMMENT;
+  return `/*
+
+This is a TestChimp Smart Test.
+Version: 1.0
+
+${hashtagString}
+
+*/`;
 }
 
 /**
- * Adds the TestChimp managed test comment to the beginning of a script
+ * Adds the TestChimp smart test comment to the beginning of a script
  * @param script The original script content
  * @param repairAdvice Optional repair advice to include in the comment
+ * @param hashtags Optional hashtags for semantic grouping
  * @returns The script with TestChimp comment prepended
  */
-export function addTestChimpComment(script: string, repairAdvice?: string): string {
+export function addTestChimpComment(script: string, repairAdvice?: string, hashtags?: string[]): string {
   // If the script already has the TestChimp comment, update it with repair advice if provided
-  if (script.includes('This is a TestChimp Managed Test')) {
+  // Prioritize Smart Test detection, fallback to Managed Test for backward compatibility
+  if (script.includes('This is a TestChimp Smart Test') || script.includes('This is a TestChimp Managed Test')) {
     if (repairAdvice) {
       // Replace existing comment with new one that includes repair advice
-      const commentRegex = /\/\*[\s\S]*?This is a TestChimp Managed Test\.[\s\S]*?\*\//;
-      const newComment = generateTestChimpComment(repairAdvice);
+      const commentRegex = /\/\*[\s\S]*?This is a TestChimp (Managed|Smart) Test\.[\s\S]*?\*\//;
+      const newComment = generateTestChimpComment(repairAdvice, hashtags);
       return script.replace(commentRegex, newComment);
     }
     return script;
   }
 
   // Add the comment at the beginning of the script
-  const comment = generateTestChimpComment(repairAdvice);
+  const comment = generateTestChimpComment(repairAdvice, hashtags);
   return `${comment}\n\n${script}`;
 }
 
@@ -60,24 +76,22 @@ export function addTestChimpComment(script: string, repairAdvice?: string): stri
  * Generates a complete test script with TestChimp comment, imports, and test structure
  * @param testName The name of the test
  * @param steps Array of test steps with descriptions and commands
- * @param includeTestChimpComment Whether to include the TestChimp managed test comment
  * @param repairAdvice Optional repair advice to include in the comment
+ * @param hashtags Optional hashtags for semantic grouping
  * @returns The complete test script
  */
 export function generateTestScript(
   testName: string, 
   steps: Array<{ stepNumber: number; description: string; playwrightCommand?: string; success?: boolean }>,
-  includeTestChimpComment: boolean = true,
-  repairAdvice?: string
+  repairAdvice?: string,
+  hashtags?: string[]
 ): string {
   const scriptLines: string[] = [];
   
-  // Add TestChimp comment if requested
-  if (includeTestChimpComment) {
-    const comment = generateTestChimpComment(repairAdvice);
-    scriptLines.push(comment);
-    scriptLines.push('');
-  }
+  // Always add TestChimp comment
+  const comment = generateTestChimpComment(repairAdvice, hashtags);
+  scriptLines.push(comment);
+  scriptLines.push('');
   
   // Add imports
   scriptLines.push(`import { test, expect } from '@playwright/test';`);
@@ -100,10 +114,12 @@ export function generateTestScript(
 }
 
 /**
- * Checks if a script is a TestChimp managed test
+ * Checks if a script is a TestChimp managed/smart test
+ * Prioritizes detection of "Smart Test" format while maintaining backward compatibility with "Managed Test"
  * @param script The script content to check
- * @returns True if the script contains the TestChimp managed test comment
+ * @returns True if the script contains the TestChimp smart/managed test comment
  */
 export function isTestChimpManagedTest(script: string): boolean {
-  return script.includes('This is a TestChimp Managed Test');
+  // Prioritize Smart Test detection, fallback to Managed Test for backward compatibility
+  return script.includes('This is a TestChimp Smart Test') || script.includes('This is a TestChimp Managed Test');
 }