@sun-asterisk/sungen 2.4.6 → 2.5.0

package/src/generators/test-generator/adapters/playwright/templates/test-file.hbs

@@ -1,4 +1,8 @@
 {{imports}}
+{{#if runtimeData}}
+
+const testData = TestDataLoader.load('{{screenName}}', '{{featureFileName}}');
+{{/if}}
 
 {{#if featureDescription}}
 /**
@@ -11,10 +15,30 @@ test.describe('{{featureName}}', () => {
 {{#if singleAuthRole}}
   test.use({ storageState: 'specs/.auth/{{singleAuthRole}}.json' });
 
+{{/if}}
+{{#if cleanupConfig}}
+  test.use({ autoCleanup: { {{cleanupConfig}} } });
+
+{{/if}}
+{{#if screenshotOnFailure}}
+  test.use({ screenshotOnFailure: true });
+
+{{/if}}
+{{#if beforeAll}}
+{{beforeAll}}
+
 {{/if}}
 {{#if background}}
 {{background}}
 
+{{/if}}
+{{#if afterEach}}
+{{afterEach}}
+
+{{/if}}
+{{#if afterAll}}
+{{afterAll}}
+
 {{/if}}
 {{#if authGroups}}
 {{#each authGroups}}

package/src/generators/test-generator/code-generator.ts

@@ -3,6 +3,7 @@ import path from 'path';
 import { ParsedFeature, ParsedScenario, ParsedStep } from '../gherkin-parser';
 import { StepMapper } from './step-mapper';
 import { TestGeneratorAdapter, adapterRegistry } from './adapters';
+import { transformToRuntimeData } from './utils/runtime-data-transformer';
 
 /**
  * Filter base scenario steps for @extend: only keep Given→When steps.
@@ -27,6 +28,33 @@ function filterBaseStepsForExtend(steps: ParsedStep[]): ParsedStep[] {
   return result;
 }
 
+/**
+ * Extract @cleanup:* tags into autoCleanup config string for test.use()
+ * @cleanup:overlay @cleanup:forms → 'overlay: true, forms: true'
+ */
+function extractCleanupConfig(tags: string[]): string | undefined {
+  const validKeys = ['overlay', 'forms', 'scroll', 'storage'];
+  const entries = tags
+    .filter(t => t.startsWith('@cleanup:'))
+    .map(t => t.replace('@cleanup:', ''))
+    .filter(key => {
+      if (!validKeys.includes(key)) {
+        console.warn(`⚠ Unknown @cleanup:${key} — valid options: ${validKeys.join(', ')}`);
+        return false;
+      }
+      return true;
+    });
+  if (entries.length === 0) return undefined;
+  return entries.map(key => `${key}: true`).join(', ');
+}
+
+/**
+ * Check for @screenshot:on-failure tag
+ */
+function hasScreenshotOnFailure(tags: string[]): boolean {
+  return tags.includes('@screenshot:on-failure');
+}
+
 /**
  * Extract auth role from tags
  * @auth:admin → 'admin'
@@ -106,7 +134,7 @@ export class CodeGenerator {
   // Steps registry built per feature during generateTestCode(); used by countSteps()
   private stepsRegistry = new Map<string, ParsedScenario>();
 
-  constructor(options: { useAI?: boolean; verbose?: boolean; framework?: string; baseURL?: string; screenName?: string } = {}) {
+  constructor(options: { useAI?: boolean; verbose?: boolean; framework?: string; baseURL?: string; screenName?: string; runtimeData?: boolean } = {}) {
     this.options = options;
     this.screenName = options.screenName;
     this.stepMapper = new StepMapper(options);
@@ -155,14 +183,19 @@ export class CodeGenerator {
       : path.join(outputDir, fileName);
 
     // Generate imports using adapter
-    const imports = this.adapter.renderImports();
+    const imports = this.adapter.renderImports({ runtimeData: this.options.runtimeData });
 
     // Generate test code (async now to support AI mapping)
     const testCode = await this.generateTestCode(feature);
 
     // Combine and collapse any runs of 3+ newlines down to 2 (one blank line max)
     const raw = `${imports}\n\n${testCode}`;
-    const code = raw.replace(/\n{3,}/g, '\n\n');
+    let code = raw.replace(/\n{3,}/g, '\n\n');
+
+    // Runtime data: replace __SUNGEN_TD_ markers with testData.get() calls
+    if (this.options.runtimeData) {
+      code = transformToRuntimeData(code);
+    }
 
     return {
       featureName: feature.name,
@@ -180,6 +213,7 @@ export class CodeGenerator {
   private countSteps(feature: ParsedFeature): number {
     let total = 0;
     for (const scenario of feature.scenarios) {
+      if (scenario.stepsName || scenario.hookType) continue;
       if (scenario.extendsName) {
         const base = this.stepsRegistry.get(scenario.extendsName);
         total += (base ? base.steps.length : 0) + scenario.steps.length;
@@ -206,17 +240,30 @@ export class CodeGenerator {
    * Ensure specs/base.ts exists in the output directory
    */
   ensureBaseFile(outputDir: string): void {
+    const templatesRoot = path.join(__dirname, '..', '..', '..', 'orchestrator', 'templates');
+
     const basePath = path.join(outputDir, 'base.ts');
-    if (fs.existsSync(basePath)) return;
+    if (!fs.existsSync(basePath)) {
+      const templatePath = path.join(templatesRoot, 'specs-base.ts');
+      if (fs.existsSync(templatePath)) {
+        const baseDir = path.dirname(basePath);
+        if (!fs.existsSync(baseDir)) {
+          fs.mkdirSync(baseDir, { recursive: true });
+        }
+        fs.copyFileSync(templatePath, basePath);
+        console.log('✓ Created: specs/base.ts');
+      }
+    }
 
-    const templatePath = path.join(__dirname, '..', '..', '..', 'orchestrator', 'templates', 'specs-base.ts');
-    if (fs.existsSync(templatePath)) {
-      const baseDir = path.dirname(basePath);
-      if (!fs.existsSync(baseDir)) {
-        fs.mkdirSync(baseDir, { recursive: true });
+    if (this.options.runtimeData) {
+      const testDataPath = path.join(outputDir, 'test-data.ts');
+      if (!fs.existsSync(testDataPath)) {
+        const templatePath = path.join(templatesRoot, 'specs-test-data.ts');
+        if (fs.existsSync(templatePath)) {
+          fs.copyFileSync(templatePath, testDataPath);
+          console.log('✓ Created: specs/test-data.ts');
+        }
       }
-      fs.copyFileSync(templatePath, basePath);
-      console.log('✓ Created: specs/base.ts');
     }
   }
 
@@ -233,12 +280,14 @@ export class CodeGenerator {
     
     // Derive screen name from source file path when not explicitly set
     // qa/screens/{screenName}/features/{featureName}.feature -> screenName
+    let effectiveScreenName = this.screenName;
     if (!this.screenName && feature.sourceFile) {
       const sourceDir = path.dirname(feature.sourceFile);
       const parts = sourceDir.split(path.sep);
       const screensIndex = parts.indexOf('screens');
       if (screensIndex >= 0 && screensIndex < parts.length - 2) {
-        this.stepMapper.setScreenContext(parts[screensIndex + 1]);
+        effectiveScreenName = parts[screensIndex + 1];
+        this.stepMapper.setScreenContext(effectiveScreenName);
       }
     }
 
@@ -261,13 +310,35 @@ export class CodeGenerator {
         this.stepsRegistry.set(scenario.stepsName, scenario);
       }
     }
-    
+
+    // Pre-pass: extract hook scenarios (@beforeAll, @afterEach, @afterAll)
+    const hookScenarios = new Map<string, ParsedScenario>();
+    for (const scenario of feature.scenarios) {
+      if (scenario.hookType) {
+        if (hookScenarios.has(scenario.hookType)) {
+          console.warn(`⚠ Duplicate @${scenario.hookType} hook — last definition wins`);
+        }
+        hookScenarios.set(scenario.hookType, scenario);
+      }
+    }
+
     // Generate background if exists
     let background: string | undefined;
     if (feature.background) {
       background = await this.generateBeforeEach(feature.background);
     }
 
+    // Generate hook blocks
+    const beforeAll = hookScenarios.has('beforeAll')
+      ? await this.generateHook(hookScenarios.get('beforeAll')!, 'beforeAll')
+      : undefined;
+    const afterEach = hookScenarios.has('afterEach')
+      ? await this.generateHook(hookScenarios.get('afterEach')!, 'afterEach')
+      : undefined;
+    const afterAll = hookScenarios.has('afterAll')
+      ? await this.generateHook(hookScenarios.get('afterAll')!, 'afterAll')
+      : undefined;
+
     // Generate all scenarios with feature tags for inheritance
     // Skip scenarios tagged with @manual
     // Track auth role per scenario for grouping
@@ -280,6 +351,11 @@ export class CodeGenerator {
         continue;
       }
 
+      // Skip hook scenarios — already generated as hook blocks above
+      if (scenario.hookType) {
+        continue;
+      }
+
       // Resolve auth tags for @extend scenarios (same logic as generateScenario)
       let authFeatureTags = feature.tags || [];
       if (scenario.extendsName) {
@@ -327,12 +403,24 @@ export class CodeGenerator {
       ? authGroups[0].authRole
       : undefined;
 
+    // Extract @cleanup:* tags for autoCleanup fixture config
+    const cleanupConfig = extractCleanupConfig(feature.tags || []);
+    const screenshotOnFailure = hasScreenshotOnFailure(feature.tags || []);
+
     // Use adapter to render the complete test file structure
     return this.adapter.renderTestFile({
       imports: '', // Not used in template as it's rendered separately
       featureName: feature.name,
       featureDescription: feature.description,
       background,
+      beforeAll,
+      afterEach,
+      afterAll,
+      cleanupConfig,
+      screenshotOnFailure,
+      runtimeData: this.options.runtimeData,
+      screenName: effectiveScreenName,
+      featureFileName: featureName,
       scenarios: needsGrouping ? [] : scenarios,
       authGroups: needsGrouping ? authGroups : undefined,
       singleAuthRole,
@@ -356,6 +444,27 @@ export class CodeGenerator {
     });
   }
 
+  private async generateHook(
+    scenario: ParsedScenario,
+    hookType: 'beforeAll' | 'afterEach' | 'afterAll'
+  ): Promise<string> {
+    const steps: Array<{ comment?: string; code: string }> = [];
+    for (const step of scenario.steps) {
+      const mapped = await Promise.resolve(this.stepMapper.mapStep(step));
+      steps.push({
+        comment: mapped.comment,
+        code: this.indentCode(mapped.code, 4),
+      });
+    }
+
+    const renderMap = {
+      beforeAll: () => this.adapter.renderBeforeAll({ steps }),
+      afterEach: () => this.adapter.renderAfterEach({ steps }),
+      afterAll: () => this.adapter.renderAfterAll({ steps }),
+    };
+    return renderMap[hookType]();
+  }
+
   private async generateScenario(
     scenario: ParsedScenario, 
     hasBackground: boolean,

package/src/generators/test-generator/step-mapper.ts

@@ -35,7 +35,7 @@ export class StepMapper {
   private inRowScope: boolean = false;
   private rowScopeTable: string = '';
 
-  constructor(options: { verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string } = {}) {
+  constructor(options: { verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string; runtimeData?: boolean } = {}) {
     this.verbose = options.verbose ?? false;
     this.baseURL = options.baseURL || null;  // null means path-only navigation
     this.featureName = options.featureName;
@@ -46,7 +46,7 @@ export class StepMapper {
     this.templateEngine = new TemplateEngine(playwrightTemplatesDir);
     this.patternRegistry = new PatternRegistry();
     this.selectorResolver = new SelectorResolver(undefined, options.screenName);
-    this.dataResolver = new DataResolver(undefined, options.screenName);
+    this.dataResolver = new DataResolver(undefined, options.screenName, options.runtimeData);
 
     if (this.verbose) {
       console.log(`  [StepMapper] ${this.patternRegistry.getPatternCount()} patterns loaded`);

package/src/generators/test-generator/template-engine.ts

@@ -229,8 +229,8 @@ export class TemplateEngine {
     this.baseContext = {};
   }
 
-  renderImports(): string {
-    return this.render('imports', {});
+  renderImports(options?: { runtimeData?: boolean }): string {
+    return this.render('imports', { runtimeData: options?.runtimeData });
   }
 
   renderTestFile(data: {
@@ -238,6 +238,14 @@ export class TemplateEngine {
     featureName: string;
     featureDescription?: string;
     background?: string;
+    beforeAll?: string;
+    afterEach?: string;
+    afterAll?: string;
+    cleanupConfig?: string;
+    screenshotOnFailure?: boolean;
+    runtimeData?: boolean;
+    screenName?: string;
+    featureFileName?: string;
     scenarios: string[];
     authGroups?: Array<{ authRole?: string; scenarios: string[] }>;
     singleAuthRole?: string;
@@ -251,6 +259,24 @@ export class TemplateEngine {
     return this.render('before-each', data);
   }
 
+  renderBeforeAll(data: {
+    steps: Array<{ comment?: string; code: string }>;
+  }): string {
+    return this.render('before-all', data);
+  }
+
+  renderAfterEach(data: {
+    steps: Array<{ comment?: string; code: string }>;
+  }): string {
+    return this.render('after-each', data);
+  }
+
+  renderAfterAll(data: {
+    steps: Array<{ comment?: string; code: string }>;
+  }): string {
+    return this.render('after-all', data);
+  }
+
   renderScenario(data: {
     scenarioName: string;
     steps: Array<{ comment?: string; code: string }>;

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

@@ -5,8 +5,11 @@ import { readYamlIfExists } from '../../../utils/yaml-io';
 
 /**
  * DataResolver - Resolves data references to actual values
- * at generation time (not runtime)
- * 
+ *
+ * Two modes:
+ * - Compile-time (default): resolves YAML values and bakes them into generated code
+ * - Runtime (runtimeMode=true): returns markers that post-processor converts to testData.get() calls
+ *
  * Supports override files with priority:
  * 1. .override.yaml (highest - user customizations)
  * 2. -override.yaml (legacy - backward compat)
@@ -16,10 +19,12 @@ export class DataResolver {
   private dataCache = new Map<string, any>();
   private testDataDir: string;
   private screenName?: string;
+  private runtimeMode: boolean;
 
-  constructor(testDataDir?: string, screenName?: string) {
+  constructor(testDataDir?: string, screenName?: string, runtimeMode: boolean = false) {
     this.testDataDir = testDataDir || path.join(process.cwd(), 'qa', 'test-data');
     this.screenName = screenName;
+    this.runtimeMode = runtimeMode;
   }
 
   /**
@@ -36,34 +41,18 @@ export class DataResolver {
    * @returns The resolved value
    */
   resolveData(dataRef: string, featureName?: string): string {
-    // Split into parts: email.valid -> [email, valid]
-    // Use only dot (.) as separator
-    const parts = dataRef.split('.');
-    
-    if (parts.length < 1) {
-      throw new Error(`Invalid data reference: ${dataRef}. Expected format: path.to.value`);
+    if (this.runtimeMode) {
+      this.validateDataRef(dataRef, featureName);
+      return DataResolver.encodeMarker(dataRef);
     }
 
-    // If featureName provided, use it as the file name
-    // Otherwise, use first part as filename (backward compatibility)
-    let fileName: string;
-    let valuePath: string[];
-    
-    if (featureName) {
-      fileName = featureName;
-      valuePath = parts;
-    } else {
-      if (parts.length < 2) {
-        throw new Error(`Invalid data reference: ${dataRef}. Expected format: file.path.to.value or provide featureName`);
-      }
-      fileName = parts[0];
-      valuePath = parts.slice(1);
-    }
+    return this.resolveValue(dataRef, featureName);
+  }
 
-    // Load data file
+  private resolveValue(dataRef: string, featureName?: string): string {
+    const { fileName, valuePath } = this.parseDataRef(dataRef, featureName);
     const data = this.loadDataFile(fileName);
 
-    // Navigate to the value
     let current = data;
     for (const key of valuePath) {
       if (current && typeof current === 'object' && key in current) {
@@ -75,7 +64,6 @@ export class DataResolver {
       }
     }
 
-    // Return as string
     if (typeof current === 'string') {
       return current;
     } else if (typeof current === 'number' || typeof current === 'boolean') {
@@ -87,6 +75,36 @@ export class DataResolver {
     }
   }
 
+  private validateDataRef(dataRef: string, featureName?: string): void {
+    // Same navigation as resolveValue — validates the key path exists at compile time
+    this.resolveValue(dataRef, featureName);
+  }
+
+  private parseDataRef(dataRef: string, featureName?: string): { fileName: string; valuePath: string[] } {
+    const parts = dataRef.split('.');
+
+    if (parts.length < 1) {
+      throw new Error(`Invalid data reference: ${dataRef}. Expected format: path.to.value`);
+    }
+
+    if (featureName) {
+      return { fileName: featureName, valuePath: parts };
+    }
+
+    if (parts.length < 2) {
+      throw new Error(`Invalid data reference: ${dataRef}. Expected format: file.path.to.value or provide featureName`);
+    }
+    return { fileName: parts[0], valuePath: parts.slice(1) };
+  }
+
+  static encodeMarker(ref: string): string {
+    return `__SUNGEN_TD_${ref.replace(/\./g, '_D_')}__`;
+  }
+
+  static decodeMarker(encoded: string): string {
+    return encoded.replace(/^__SUNGEN_TD_/, '').replace(/__$/, '').replace(/_D_/g, '.');
+  }
+
   /**
    * Load data file from disk (with caching)
    * Searches new screen-based directory structure only

package/src/generators/test-generator/utils/runtime-data-transformer.ts

@@ -0,0 +1,51 @@
+const MARKER_PATTERN = /__SUNGEN_TD_([A-Za-z0-9_]+)__/;
+
+/**
+ * Replace __SUNGEN_TD_ markers with testData.get() calls in generated code.
+ * Three passes: comments, string literals, then regex literals.
+ */
+export function transformToRuntimeData(code: string): string {
+  // Pass 0: Comments — replace markers in // comments with decoded key name
+  // Prevents Pass 2 from misinterpreting // comment markers as regex delimiters
+  code = code.replace(
+    /\/\/(.*)__SUNGEN_TD_([A-Za-z0-9_]+)__(.*)/g,
+    (_, before, enc, after) => `//${before}${decodeKey(enc)}${after}`
+  );
+
+  // Pass 1: String literal context — handles both whole-string and embedded markers
+  // 'marker'                    → testData.get('key')
+  // 'prefix__marker__suffix'    → `prefix${testData.get('key')}suffix`
+  code = code.replace(
+    /(['"])((?:(?!\1).)*?)__SUNGEN_TD_([A-Za-z0-9_]+)__((?:(?!\1).)*?)\1/g,
+    (_, _quote, prefix, enc, suffix) => {
+      const key = decodeKey(enc);
+      if (!prefix && !suffix) {
+        return `testData.get('${key}')`;
+      }
+      return `\`${prefix}\${testData.get('${key}')}${suffix}\``;
+    }
+  );
+
+  // Pass 2: Regex literal context — /prefix__marker__suffix/ → new RegExp(`...`)
+  // Only matches within a single line (no newlines in prefix/suffix)
+  code = code.replace(
+    /\/((?:[^/\\\n]|\\.)*?)__SUNGEN_TD_([A-Za-z0-9_]+)__((?:[^/\\\n]|\\.)*?)\/([gimsuy]*)/g,
+    (_, prefix, enc, suffix, flags) => {
+      const key = decodeKey(enc);
+      const ref = `testData.get('${key}')`;
+      const flagStr = flags ? `, '${flags}'` : '';
+      if (!prefix && !suffix) return `new RegExp(${ref}${flagStr})`;
+      return `new RegExp(\`${prefix}\${${ref}}${suffix}\`${flagStr})`;
+    }
+  );
+
+  return code;
+}
+
+export function hasRuntimeDataMarkers(code: string): boolean {
+  return MARKER_PATTERN.test(code);
+}
+
+function decodeKey(encoded: string): string {
+  return encoded.replace(/_D_/g, '.');
+}

package/src/generators/types.ts

@@ -170,6 +170,7 @@ export interface GenerateOptions {
   all?: boolean;                  // Generate all screens
   force?: boolean;                // Force re-generation
   skipCache?: boolean;            // Skip cache lookup
+  runtimeData?: boolean;          // Runtime data loading (default: true). False = compile-time hardcoding.
 }
 
 export interface ValidateOptions {

package/src/orchestrator/project-initializer.ts

@@ -48,8 +48,9 @@ export class ProjectInitializer {
     // Create tsconfig.json if doesn't exist
     this.createTsConfig();
 
-    // Create specs/base.ts for shared context
+    // Create specs/base.ts for shared context and specs/test-data.ts for runtime data
     this.createSpecsBase();
+    this.createSpecsTestData();
 
     // Create/update .gitignore
     this.updateGitignore();
@@ -383,6 +384,27 @@ export class ProjectInitializer {
     this.createdItems.push('specs/generated/base.ts');
   }
 
+  /**
+   * Create specs/test-data.ts for runtime YAML loading
+   */
+  private createSpecsTestData(): void {
+    const testDataPath = path.join(this.cwd, 'specs', 'generated', 'test-data.ts');
+
+    if (fs.existsSync(testDataPath)) {
+      this.skippedItems.push('specs/generated/test-data.ts');
+      return;
+    }
+
+    const baseDir = path.dirname(testDataPath);
+    if (!fs.existsSync(baseDir)) {
+      fs.mkdirSync(baseDir, { recursive: true });
+    }
+
+    const content = this.readTemplate('specs-test-data.ts');
+    fs.writeFileSync(testDataPath, content, 'utf-8');
+    this.createdItems.push('specs/generated/test-data.ts');
+  }
+
   /**
    * Read a template file from the templates directory
    */
@@ -405,26 +427,78 @@ export class ProjectInitializer {
       this.createdItems.push('package.json');
     }
 
-    // Check if @playwright/test is already installed
+    // Ensure standard scripts exist in package.json
+    this.ensurePackageScripts(packageJsonPath);
+
+    // Check which dependencies are missing
+    const requiredDeps = ['@playwright/test', '@types/node', 'yaml'];
+    let missingDeps: string[] = requiredDeps;
     try {
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
       const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-      if (deps['@playwright/test']) {
-        console.log('✓ @playwright/test already installed\n');
-        return;
-      }
+      missingDeps = requiredDeps.filter(d => !deps[d]);
     } catch {
-      // package.json just created, proceed with install
+      // package.json just created, install all
+    }
+
+    if (missingDeps.length === 0) {
+      console.log('✓ All dependencies already installed\n');
+      return;
     }
 
-    // Install Playwright and TypeScript types
-    console.log('📦 Installing @playwright/test and @types/node...\n');
-    execSync('npm install -D @playwright/test @types/node', execOpts);
+    console.log(`📦 Installing ${missingDeps.join(', ')}...\n`);
+    execSync(`npm install -D ${missingDeps.join(' ')}`, execOpts);
 
     console.log('\n🎭 Installing Playwright browsers...\n');
     execSync('npx playwright install', execOpts);
   }
 
+  /**
+   * Ensure package.json has standard Playwright + Sungen scripts.
+   * Only adds missing scripts — never overwrites user customizations.
+   */
+  private ensurePackageScripts(packageJsonPath: string): void {
+    let packageJson: Record<string, any>;
+    try {
+      packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    } catch {
+      return;
+    }
+
+    if (!packageJson.scripts || typeof packageJson.scripts !== 'object') {
+      packageJson.scripts = {};
+    }
+
+    const standardScripts: Record<string, string> = {
+      'test': 'playwright test specs/generated/',
+      'test:headed': 'playwright test specs/generated/ --headed',
+      'test:debug': 'playwright test specs/generated/ --debug',
+      'test:ui': 'playwright test specs/generated/ --ui',
+      'report': 'playwright show-report',
+      'generate': 'sungen generate --all',
+      'install:browsers': 'npx playwright install chromium',
+    };
+
+    let added = 0;
+    for (const [name, command] of Object.entries(standardScripts)) {
+      // Skip if user already has this script (don't overwrite)
+      // Exception: overwrite the npm init default test script
+      const existing = packageJson.scripts[name];
+      if (existing && existing !== 'echo "Error: no test specified" && exit 1') {
+        continue;
+      }
+      packageJson.scripts[name] = command;
+      added++;
+    }
+
+    if (added > 0) {
+      // Also mark as private (test projects should not be published)
+      packageJson.private = true;
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+      console.log(`📝 Added ${added} standard script(s) to package.json\n`);
+    }
+  }
+
   /**
    * Get Playwright configuration template
    */

package/src/orchestrator/templates/ai-instructions/claude-cmd-run-test.md

@@ -18,7 +18,7 @@ Parse **screen** from `$ARGUMENTS`. If missing, ask the user.
 1. Verify `qa/screens/<screen>/` has `.feature` + `test-data.yaml`.
 2. **Phase 0 — Selector Pre-gen**: if `selectors.yaml` is missing/empty or doesn't cover the feature file's `[Reference]`s, run Phase 0 from `sungen-selector-fix` — confirm with user, `browser_navigate` → one `browser_snapshot` → merge YAML entries.
 3. **Phase 0.5 — Auth Persistence**: if the feature has `@auth:<role>` tags and `specs/.auth/<role>.json` is missing/expired, run Phase 0.5 from `sungen-selector-fix` — user logs in manually in MCP browser → `browser_storage_state` → `specs/.auth/<role>.json`. Offer `sungen makeauth <role>` as CLI fallback only if `browser_storage_state` isn't available in this MCP version.
-4. Compile: `sungen generate --screen <screen>`.
+4. Compile: `sungen generate --screen <screen>` (default: runtime data loading from YAML). Use `--inline-data` only if user requests compile-time hardcoded values.
 
 ## Run & Fix (phased — per `sungen-selector-fix` skill)