@sun-asterisk/sungen 1.0.20 → 1.0.21

package/src/cli/commands/{live-scan-command.ts → live-scan.ts}

@@ -1,17 +1,8 @@
-/**
- * Live Scan CLI Command
- * Launches a browser, replays Gherkin steps, and produces .live-scan.yaml matrix files.
- * Auto-detects baseURL from playwright.config.ts.
- */
-
 import { Command } from 'commander';
-import { RuntimeConfig } from '../../config/config-schema';
-import { LiveScanner } from '../../core/live-scanner';
-
-export function createLiveScanCommand(config: RuntimeConfig): Command {
-  const cmd = new Command('live-scan');
 
-  cmd
+export function registerLiveScanCommand(program: Command): void {
+  program
+    .command('live-scan')
     .description('Scan a live site to discover real selectors for Gherkin element references')
     .requiredOption('-s, --screen <name>', 'Screen name to scan')
     .option('--url <baseUrl>', 'Override base URL (default: read from playwright.config.ts)')
@@ -20,6 +11,8 @@ export function createLiveScanCommand(config: RuntimeConfig): Command {
     .option('-f, --force', 'Force rescan all elements, ignoring existing results', false)
     .action(async (options) => {
       try {
+        const { LiveScanner } = require('../../core/live-scanner');
+
         console.log('\n🔍 Sungen Live Scanner\n');
         console.log(`📍 Screen: ${options.screen}`);
         console.log(`🖥️  Mode: ${options.headed ? 'headed' : 'headless'}`);
@@ -28,7 +21,7 @@ export function createLiveScanCommand(config: RuntimeConfig): Command {
         }
 
         const scanner = new LiveScanner({
-          baseUrl: options.url,  // undefined = auto-detect from playwright.config.ts
+          baseUrl: options.url,
           screenName: options.screen,
           screensDir: 'qa/screens',
           headed: options.headed,
@@ -48,8 +41,8 @@ export function createLiveScanCommand(config: RuntimeConfig): Command {
         let totalSkipped = 0;
 
         for (const result of results) {
-          for (const scenario of Object.values(result.scenarios)) {
-            for (const element of Object.values(scenario.elements)) {
+          for (const scenario of Object.values(result.scenarios) as any[]) {
+            for (const element of Object.values(scenario.elements) as any[]) {
               totalElements++;
               if ((element as any).skipped) {
                 totalSkipped++;
@@ -86,6 +79,4 @@ export function createLiveScanCommand(config: RuntimeConfig): Command {
         process.exit(1);
       }
     });
-
-  return cmd;
 }

package/src/cli/commands/makeauth.ts

@@ -0,0 +1,77 @@
+import { Command } from 'commander';
+
+export function registerMakeauthCommand(program: Command): void {
+  program
+    .command('makeauth <name>')
+    .description('Generate auth state by opening browser for manual SSO login')
+    .option('-u, --url <url>', 'Base URL of the application')
+    .option('-p, --path <path>', 'Login page path (default: /login)')
+    .option('-o, --output <dir>', 'Output directory (default: specs/.auth)')
+    .option('-t, --timeout <ms>', 'Overall timeout in milliseconds (default: 180000)')
+    .option('--nav-timeout <ms>', 'Navigation timeout in milliseconds')
+    .option('--stability-wait <ms>', 'Wait time to confirm login stability')
+    .option('--headless', 'Run in headless mode (not recommended for SSO)')
+    .option('-l, --list', 'List existing auth states')
+    .option('--verify', 'Verify an existing auth state is still valid')
+    .option('--export', 'Export auth state as base64 (for CI)')
+    .action(async (name: string, options: any) => {
+      try {
+        const { AuthMaker } = require('../../tools/auth-maker');
+
+        const authMaker = new AuthMaker({
+          baseURL: options.url,
+          loginPath: options.path || '/login',
+          outputDir: options.output || 'specs/.auth',
+          timeout: options.timeout ? parseInt(options.timeout, 10) : undefined,
+          navigationTimeout: options.navTimeout ? parseInt(options.navTimeout, 10) : undefined,
+          stabilityWait: options.stabilityWait ? parseInt(options.stabilityWait, 10) : undefined,
+        });
+
+        if (options.list) {
+          const authStates = authMaker.listAuth();
+          if (authStates.length === 0) {
+            console.log('No auth states found.');
+          } else {
+            console.log('Available auth states:');
+            for (const state of authStates) {
+              console.log(`  - ${state}`);
+            }
+          }
+          return;
+        }
+
+        if (options.verify) {
+          const isValid = await authMaker.verifyAuth(name);
+          process.exit(isValid ? 0 : 1);
+        }
+
+        if (options.export) {
+          const base64 = authMaker.exportAuth(name);
+          if (base64) {
+            console.log('');
+            console.log('Base64 Auth State (for CI):');
+            console.log('========================================');
+            console.log(base64);
+            console.log('========================================');
+            console.log('');
+            console.log('Save this to CI secret: AUTH_STATE_' + name.toUpperCase());
+          }
+          return;
+        }
+
+        await authMaker.makeAuth({
+          name,
+          baseURL: options.url,
+          loginPath: options.path,
+          outputDir: options.output,
+          timeout: options.timeout ? parseInt(options.timeout, 10) : undefined,
+          navigationTimeout: options.navTimeout ? parseInt(options.navTimeout, 10) : undefined,
+          stabilityWait: options.stabilityWait ? parseInt(options.stabilityWait, 10) : undefined,
+          headless: options.headless,
+        });
+      } catch (error) {
+        console.error('❌ Auth generation failed:', error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/map.ts

@@ -0,0 +1,97 @@
+import { Command } from 'commander';
+import { ConfigLoader } from '../../config/config-loader';
+
+export function registerMapCommand(program: Command): void {
+  program
+    .command('map')
+    .description('Generate selector and test-data YAML from Gherkin feature files')
+    .option('-s, --screen <name>', 'Screen name (reads from qa/screens/<name>/features/)')
+    .option('--file <path>', 'Single feature file path (generates selectors next to features folder)')
+    .option('-o, --output <dir>', 'Output directory for generated files')
+    .option('-f, --force', 'Force overwrite existing YAML files and rescan all elements')
+    .option('--skip-live-scan', 'Skip live-scan before mapping (live-scan runs by default)')
+    .option('--headed', 'Launch browser in headed mode during live-scan', false)
+    .option('--auth-dir <path>', 'Auth storage state directory for live-scan', 'specs/.auth')
+    .option('-v, --verbose', 'Detailed output')
+    .action(async (options) => {
+      try {
+        const path = require('path');
+        const cliOptions = {
+          ...program.opts(),
+          ...options,
+        };
+        const config = new ConfigLoader().load(cliOptions);
+        const { ScaffoldGenerator } = require('../../generators/scaffold-generator');
+
+        const generator = new ScaffoldGenerator();
+
+        if (options.screen) {
+          const screensDir = options.output || 'qa/screens';
+          const forceOverwrite = cliOptions.force || false;
+
+          // Run live-scan by default before mapping (skip with --skip-live-scan)
+          if (!options.skipLiveScan) {
+            const { LiveScanner } = require('../../core/live-scanner');
+            console.log('🔍 Running live-scan before mapping...\n');
+
+            const scanner = new LiveScanner({
+              screenName: options.screen,
+              screensDir,
+              headed: options.headed,
+              authDir: options.authDir,
+            });
+
+            await scanner.scan();
+            console.log('');
+          }
+
+          if (forceOverwrite) {
+            console.log(`Mapping screen: ${options.screen} (force: selectors will be overwritten)\n`);
+          } else {
+            console.log(`Mapping screen: ${options.screen}\n`);
+          }
+
+          const results = generator.processScreen(options.screen, screensDir, forceOverwrite);
+
+          for (const result of results) {
+            console.log(`✓ Mapped ${result.featureFile}.feature`);
+
+            if (result.selectorsSkipped) {
+              console.log(`   ⊘ ${path.basename(result.selectorsPath)} (skipped - already exists)`);
+            } else {
+              console.log(`   → ${path.basename(result.selectorsPath)} (${result.elementCount} elements)`);
+            }
+
+            if (result.testDataMerged) {
+              console.log(`   ↻ ${path.basename(result.testDataPath)} (smart-merged — ${result.dataRefCount} variables)\n`);
+            } else {
+              console.log(`   → ${path.basename(result.testDataPath)} (${result.dataRefCount} variables)\n`);
+            }
+          }
+
+          console.log(`Next step: sungen generate --screen ${options.screen}`);
+          console.log('     This will create the test specs based on the mapped selectors and test data.');
+        } else if (options.file) {
+          const deriveOutputDir = (featureFilePath: string): string => {
+            const featureDir = path.dirname(featureFilePath);
+            if (featureDir.includes('features')) {
+              return featureDir.replace(/features\/?$/, 'selectors/screens');
+            }
+            return path.join(featureDir, '..', 'selectors', 'screens');
+          };
+
+          const outputDir = options.output || deriveOutputDir(options.file);
+          const forceOverwrite = cliOptions.force || false;
+          console.log(`Mapping from file: ${options.file}\n`);
+          const result = generator.processFeatureFile(options.file, outputDir, forceOverwrite);
+          console.log(`✓ Generated: ${result.outputPath} (${result.elementCount} elements)`);
+        } else {
+          console.error('❌ Error: Please specify --screen <name> or --file <path>');
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error('❌ Mapping failed:', error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/validate.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { ValidationResult } from '../../core/validator';
+import { printValidationResult } from '../utils';
+
+export function registerValidateCommand(program: Command): void {
+  program
+    .command('validate')
+    .description('Validate Gherkin features and selector/test-data mappings')
+    .option('-s, --screen <name>', 'Validate specific screen (optional, defaults to all)')
+    .option('--json', 'Output results as JSON')
+    .option('-v, --verbose', 'Show all checks, not just failures')
+    .action(async (options) => {
+      try {
+        const { ScreenValidator } = require('../../core/validator');
+
+        const validator = new ScreenValidator({
+          verbose: options.verbose,
+        });
+
+        let result: ValidationResult;
+        if (options.screen) {
+          console.log(`Validating screen: ${options.screen}\n`);
+          result = validator.validateScreen(options.screen);
+        } else {
+          console.log('Validating all screens...\n');
+          result = validator.validateAll();
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          printValidationResult(result, options.verbose);
+        }
+
+        if (!result.valid) {
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error('❌ Validation failed:', error);
+        process.exit(1);
+      }
+    });
+}