@toolstackhq/create-qa-patterns 1.0.11 → 1.0.13

package/README.md

@@ -34,6 +34,12 @@ Generate the Cypress template explicitly:
 create-qa-patterns cypress-template my-project
 ```
 
+Generate without post-create prompts, which is useful for CI or scripted setup:
+
+```bash
+create-qa-patterns playwright-template my-project --yes --no-install --no-setup --no-test
+```
+
 ## Supported templates
 
 - `playwright-template`
@@ -54,6 +60,14 @@ For Playwright projects, the interactive flow also offers:
 
 - `npx playwright install`
 
+For non-interactive automation, the CLI also supports:
+
+- `--yes`
+- `--no-install`
+- `--no-setup`
+- `--no-test`
+- `--template <template>`
+
 ## Prerequisite checks
 
 The CLI checks:

package/index.js

@@ -118,6 +118,14 @@ Usage:
   create-qa-patterns
   create-qa-patterns <target-directory>
   create-qa-patterns <template> [target-directory]
+  create-qa-patterns --template <template> [target-directory]
+
+Options:
+  --yes          Accept all post-generate prompts
+  --no-install   Skip npm install
+  --no-setup     Skip template-specific setup such as Playwright browser install
+  --no-test      Skip npm test
+  --template     Explicitly choose a template without using positional arguments
 
 Interactive mode:
   When run without an explicit template, the CLI shows an interactive template picker.
@@ -127,6 +135,58 @@ ${supportedTemplates}
 `);
 }
 
+function parseCliOptions(args) {
+  const options = {
+    yes: false,
+    noInstall: false,
+    noSetup: false,
+    noTest: false,
+    templateName: null,
+    positionalArgs: []
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    switch (arg) {
+      case "--yes":
+        options.yes = true;
+        break;
+      case "--no-install":
+        options.noInstall = true;
+        break;
+      case "--no-setup":
+        options.noSetup = true;
+        break;
+      case "--no-test":
+        options.noTest = true;
+        break;
+      case "--template": {
+        const templateValue = args[index + 1];
+        if (!templateValue) {
+          throw new Error("Missing value for --template.");
+        }
+
+        const templateName = resolveTemplate(templateValue);
+        if (!templateName) {
+          throw new Error(
+            `Unsupported template "${templateValue}". Supported templates: ${TEMPLATES.map((template) => template.id).join(", ")}.`
+          );
+        }
+
+        options.templateName = templateName;
+        index += 1;
+        break;
+      }
+      default:
+        options.positionalArgs.push(arg);
+        break;
+    }
+  }
+
+  return options;
+}
+
 function parseNodeVersion(version) {
   const normalized = version.replace(/^v/, "");
   const [major = "0", minor = "0", patch = "0"] = normalized.split(".");
@@ -347,7 +407,27 @@ async function selectTemplateInteractively() {
   });
 }
 
-function resolveNonInteractiveArgs(args) {
+function resolveNonInteractiveArgs(args, options = {}) {
+  if (options.templateName) {
+    if (args.length > 1) {
+      throw new Error("Too many arguments. Run `create-qa-patterns --help` for usage.");
+    }
+
+    if (args.length === 0) {
+      return {
+        templateName: options.templateName,
+        targetDirectory: process.cwd(),
+        generatedInCurrentDirectory: true
+      };
+    }
+
+    return {
+      templateName: options.templateName,
+      targetDirectory: path.resolve(process.cwd(), args[0]),
+      generatedInCurrentDirectory: false
+    };
+  }
+
   if (args.length === 0) {
     return {
       templateName: DEFAULT_TEMPLATE,
@@ -670,20 +750,22 @@ function printSummary(summary) {
 }
 
 async function runPostGenerateActions(template, targetDirectory, summary) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    return;
-  }
-
   const prerequisites = collectPrerequisites();
+  const options = summary.options;
+  const canPrompt = process.stdin.isTTY && process.stdout.isTTY;
 
   if (prerequisites.npm) {
-    const shouldInstallDependencies = await askYesNo("Run npm install now?", true);
-
-    if (shouldInstallDependencies) {
-      await runCommand("npm", ["install"], targetDirectory);
-      summary.npmInstall = "completed";
-    } else {
+    if (options.noInstall) {
       summary.npmInstall = "skipped";
+    } else {
+      const shouldInstallDependencies = options.yes ? true : canPrompt ? await askYesNo("Run npm install now?", true) : false;
+
+      if (shouldInstallDependencies) {
+        await runCommand("npm", ["install"], targetDirectory);
+        summary.npmInstall = "completed";
+      } else {
+        summary.npmInstall = canPrompt ? "skipped" : "not-run";
+      }
     }
   } else {
     process.stdout.write(`${colors.yellow("Skipping")} npm install prompt because npm is not available.\n`);
@@ -691,8 +773,10 @@ async function runPostGenerateActions(template, targetDirectory, summary) {
   }
 
   if (template.setup) {
-    if (prerequisites[template.setup.availability]) {
-      const shouldRunExtraSetup = await askYesNo(template.setup.prompt, true);
+    if (options.noSetup) {
+      summary.extraSetup = "skipped";
+    } else if (prerequisites[template.setup.availability]) {
+      const shouldRunExtraSetup = options.yes ? true : canPrompt ? await askYesNo(template.setup.prompt, true) : false;
 
       if (shouldRunExtraSetup) {
         try {
@@ -711,7 +795,7 @@ async function runPostGenerateActions(template, targetDirectory, summary) {
           }
         }
       } else {
-        summary.extraSetup = "skipped";
+        summary.extraSetup = canPrompt ? "skipped" : "not-run";
       }
     } else {
       process.stdout.write(
@@ -722,13 +806,17 @@ async function runPostGenerateActions(template, targetDirectory, summary) {
   }
 
   if (prerequisites.npm) {
-    const shouldRunTests = await askYesNo("Run npm test now?", false);
-
-    if (shouldRunTests) {
-      await runCommand("npm", ["test"], targetDirectory);
-      summary.testRun = "completed";
-    } else {
+    if (options.noTest) {
       summary.testRun = "skipped";
+    } else {
+      const shouldRunTests = options.yes ? true : canPrompt ? await askYesNo("Run npm test now?", false) : false;
+
+      if (shouldRunTests) {
+        await runCommand("npm", ["test"], targetDirectory);
+        summary.testRun = "completed";
+      } else {
+        summary.testRun = canPrompt ? "skipped" : "not-run";
+      }
     }
   } else {
     process.stdout.write(`${colors.yellow("Skipping")} npm test prompt because npm is not available.\n`);
@@ -737,16 +825,20 @@ async function runPostGenerateActions(template, targetDirectory, summary) {
 }
 
 async function main() {
-  const args = process.argv.slice(2);
+  const rawArgs = process.argv.slice(2);
 
   assertSupportedNodeVersion();
 
-  if (args.includes("--help") || args.includes("-h")) {
+  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
     printHelp();
     return;
   }
 
-  const { templateName, targetDirectory, generatedInCurrentDirectory } = await resolveScaffoldArgs(args);
+  const options = parseCliOptions(rawArgs);
+  const args = options.positionalArgs;
+  const { templateName, targetDirectory, generatedInCurrentDirectory } = options.templateName
+    ? resolveNonInteractiveArgs(args, options)
+    : await resolveScaffoldArgs(args);
   const template = getTemplate(templateName);
 
   if (!template) {
@@ -755,6 +847,7 @@ async function main() {
 
   const prerequisites = collectPrerequisites();
   const summary = createSummary(template, targetDirectory, generatedInCurrentDirectory);
+  summary.options = options;
   printPrerequisiteWarnings(prerequisites);
   await scaffoldProject(template, targetDirectory, prerequisites);
   summary.gitInit = prerequisites.git ? "completed" : "unavailable";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolstackhq/create-qa-patterns",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "CLI for generating QA framework templates.",
   "license": "MIT",
   "repository": {

package/templates/cypress-template/README.md

@@ -21,9 +21,11 @@ This is a Cypress + TypeScript automation framework template for a small determi
 - Cypress-native custom commands for common user actions
 - page modules that own selectors and keep spec files focused on behavior
 - generic `DataFactory` helpers for repeatable UI data
+- folder-level `README.md` guides and file-header comments for easier onboarding
 - multi-environment runtime config with `dev`, `staging`, and `prod`
 - env-based secret resolution with a replaceable `SecretProvider`
 - built-in screenshots and videos on failure
+- optional single-file Allure report
 - ESLint rules that keep selectors out of spec files
 - bundled deterministic UI demo app and GitHub Actions workflow
 
@@ -79,6 +81,12 @@ If you want to run the demo app manually for debugging:
 npm run demo:ui
 ```
 
+If you want an Allure report after a run:
+
+```bash
+npm run report:allure
+```
+
 Default local values:
 
 - UI base URL: `http://127.0.0.1:3000`
@@ -134,6 +142,7 @@ npm run demo:ui
 npm run lint
 npm run typecheck
 npm run cy:run
+npm run report:allure
 ```
 
 ## Reports and artifacts
@@ -142,9 +151,13 @@ Outputs:
 
 - Cypress videos: `reports/videos`
 - Cypress screenshots: `reports/screenshots`
+- Allure single file: `reports/allure/index.html`
+- raw Allure results: `allure-results`
 
 The default Cypress terminal output is kept as the main reporting path.
 
+If you only want Cypress's built-in output, remove the `allureCypress(...)` call in `cypress.config.ts`.
+
 ## Add a new test
 
 Create tests under `cypress/e2e/`.

package/templates/cypress-template/allurerc.mjs

@@ -0,0 +1,10 @@
+export default {
+  name: "qa-patterns Cypress Template",
+  plugins: {
+    awesome: {
+      options: {
+        singleFile: true
+      }
+    }
+  }
+};

package/templates/cypress-template/config/README.md

@@ -0,0 +1,5 @@
+# Config
+
+This folder resolves environment-specific values for the Cypress template.
+
+- Keep defaults, secret lookup, and runtime parsing here.

package/templates/cypress-template/config/environments.ts

@@ -1,3 +1,4 @@
+// Defines the built-in environment defaults used when env vars are not provided.
 import type { TestEnvironment } from "./test-env";
 
 type EnvironmentDefaults = {
@@ -8,7 +9,7 @@ type EnvironmentDefaults = {
   };
 };
 
-const environmentDefaults: Record<TestEnvironment, EnvironmentDefaults> = {
+const DEFAULTS: Record<TestEnvironment, EnvironmentDefaults> = {
   dev: {
     uiBaseUrl: "http://127.0.0.1:3000",
     credentials: {
@@ -20,18 +21,18 @@ const environmentDefaults: Record<TestEnvironment, EnvironmentDefaults> = {
     uiBaseUrl: "https://staging-ui.example.internal",
     credentials: {
       username: "staging-user",
-      password: "staging-password"
+      password: "replace-me"
     }
   },
   prod: {
     uiBaseUrl: "https://ui.example.internal",
     credentials: {
       username: "prod-user",
-      password: "prod-password"
+      password: "replace-me"
     }
   }
 };
 
-export function getEnvironmentDefaults(environment: TestEnvironment): EnvironmentDefaults {
-  return environmentDefaults[environment];
+export function getEnvironmentDefaults(testEnv: TestEnvironment): EnvironmentDefaults {
+  return DEFAULTS[testEnv];
 }

package/templates/cypress-template/config/runtime-config.ts

@@ -1,3 +1,4 @@
+// Builds the runtime configuration object that tests and fixtures consume.
 import path from "node:path";
 
 import dotenv from "dotenv";
@@ -27,6 +28,7 @@ export type RuntimeConfig = z.infer<typeof runtimeConfigSchema>;
 export function loadRuntimeConfig(): RuntimeConfig {
   const defaults = getEnvironmentDefaults(environment);
   const secretManager = new SecretManager(new EnvSecretProvider());
+
   const uiBaseUrl =
     process.env[`${environment.toUpperCase()}_UI_BASE_URL`] ??
     process.env.UI_BASE_URL ??

package/templates/cypress-template/config/secret-manager.ts

@@ -1,19 +1,29 @@
+// Minimal secret abstraction so env-based secrets can later be replaced cleanly.
 import type { TestEnvironment } from "./test-env";
 
 export interface SecretProvider {
-  getOptionalSecret(secretName: string, environment: TestEnvironment): string | undefined;
+  getSecret(key: string, testEnv: TestEnvironment): string | undefined;
 }
 
 export class EnvSecretProvider implements SecretProvider {
-  getOptionalSecret(secretName: string, environment: TestEnvironment): string | undefined {
-    return process.env[`${environment.toUpperCase()}_${secretName}`] ?? process.env[secretName];
+  getSecret(key: string, testEnv: TestEnvironment): string | undefined {
+    const envPrefix = testEnv.toUpperCase();
+    return process.env[`${envPrefix}_${key}`] ?? process.env[key];
   }
 }
 
 export class SecretManager {
-  constructor(private readonly secretProvider: SecretProvider) {}
+  constructor(private readonly provider: SecretProvider) {}
 
-  getOptionalSecret(secretName: string, environment: TestEnvironment): string | undefined {
-    return this.secretProvider.getOptionalSecret(secretName, environment);
+  getRequiredSecret(key: string, testEnv: TestEnvironment): string {
+    const value = this.provider.getSecret(key, testEnv);
+    if (!value) {
+      throw new Error(`Missing secret "${key}" for TEST_ENV=${testEnv}`);
+    }
+    return value;
+  }
+
+  getOptionalSecret(key: string, testEnv: TestEnvironment): string | undefined {
+    return this.provider.getSecret(key, testEnv);
   }
 }

package/templates/cypress-template/config/test-env.ts

@@ -1,13 +1,9 @@
-export type TestEnvironment = "dev" | "staging" | "prod";
+import { z } from "zod";
 
-const testEnvironmentValues = new Set<TestEnvironment>(["dev", "staging", "prod"]);
+export const testEnvironmentSchema = z.enum(["dev", "staging", "prod"]);
 
-export function loadTestEnvironment(): TestEnvironment {
-  const testEnv = process.env.TEST_ENV ?? "dev";
-
-  if (!testEnvironmentValues.has(testEnv as TestEnvironment)) {
-    throw new Error(`Unsupported TEST_ENV "${testEnv}". Expected one of: dev, staging, prod.`);
-  }
+export type TestEnvironment = z.infer<typeof testEnvironmentSchema>;
 
-  return testEnv as TestEnvironment;
+export function loadTestEnvironment(): TestEnvironment {
+  return testEnvironmentSchema.parse(process.env.TEST_ENV ?? "dev");
 }

package/templates/cypress-template/cypress/e2e/README.md

@@ -0,0 +1,6 @@
+# E2E Specs
+
+This folder holds Cypress scenarios.
+
+- Keep specs focused on workflow validation.
+- Use custom commands and page modules instead of raw selectors.

package/templates/cypress-template/cypress/e2e/ui-journey.cy.ts

@@ -1,3 +1,4 @@
+// Starter Cypress scenario that demonstrates the preferred spec style for this template.
 import { DataFactory } from "../support/data/data-factory";
 import { loadAppConfig } from "../support/app-config";
 import { peoplePage } from "../support/pages/people-page";

package/templates/cypress-template/cypress/support/README.md

@@ -0,0 +1,5 @@
+# Support
+
+This folder contains the reusable Cypress support layer.
+
+- Put custom commands, shared config, page modules, and test data helpers here.

package/templates/cypress-template/cypress/support/app-config.ts

@@ -1,3 +1,4 @@
+// Reads runtime values from Cypress env so specs stay clean and framework-aware.
 type Credentials = {
   username: string;
   password: string;

package/templates/cypress-template/cypress/support/commands.ts

@@ -1,3 +1,4 @@
+// Registers the custom Cypress commands that the starter specs rely on.
 import type { PersonRecord } from "./data/data-factory";
 import { loginPage } from "./pages/login-page";
 import { peoplePage } from "./pages/people-page";

package/templates/cypress-template/cypress/support/data/README.md

@@ -0,0 +1,5 @@
+# Data
+
+This folder holds generic test data builders and generators.
+
+- Keep data simple and readable for starter projects.

package/templates/cypress-template/cypress/support/data/data-factory.ts

@@ -1,5 +1,6 @@
-import { IdGenerator } from "./id-generator";
+// Generic data builders that keep tests readable and deterministic.
 import { createSeededFaker } from "./seeded-faker";
+import { IdGenerator } from "./id-generator";
 
 export type PersonRecord = {
   personId: string;

package/templates/cypress-template/cypress/support/data/id-generator.ts

@@ -1,13 +1,18 @@
+// Deterministic id generator for repeatable local and CI runs.
 export class IdGenerator {
   private readonly counters = new Map<string, number>();
 
-  constructor(private readonly testRunId: string) {}
+  constructor(private readonly runId: string) {}
 
   next(prefix: string): string {
-    const currentCount = this.counters.get(prefix) ?? 0;
-    const nextCount = currentCount + 1;
-    this.counters.set(prefix, nextCount);
+    const counter = (this.counters.get(prefix) ?? 0) + 1;
+    this.counters.set(prefix, counter);
+    return `${prefix}-${this.runId}-${String(counter).padStart(4, "0")}`;
+  }
 
-    return `${prefix}-${this.testRunId}-${String(nextCount).padStart(4, "0")}`;
+  nextSequence(prefix: string): number {
+    const counter = (this.counters.get(prefix) ?? 0) + 1;
+    this.counters.set(prefix, counter);
+    return counter;
   }
 }

package/templates/cypress-template/cypress/support/data/seeded-faker.ts

@@ -1,11 +1,14 @@
+// Seeded faker wrapper so generated values stay stable for a given run id.
 import { Faker, en } from "@faker-js/faker";
 
-function toNumericSeed(seed: string): number {
-  return seed.split("").reduce((accumulator, character) => accumulator + character.charCodeAt(0), 0);
+function hashSeed(value: string): number {
+  return value.split("").reduce((seed, character) => {
+    return ((seed << 5) - seed + character.charCodeAt(0)) | 0;
+  }, 0);
 }
 
-export function createSeededFaker(seed: string): Faker {
-  const faker = new Faker({ locale: [en] });
-  faker.seed(toNumericSeed(seed));
-  return faker;
+export function createSeededFaker(seedInput: string): Faker {
+  const instance = new Faker({ locale: [en] });
+  instance.seed(Math.abs(hashSeed(seedInput)));
+  return instance;
 }

package/templates/cypress-template/cypress/support/e2e.ts

@@ -1 +1,2 @@
+import "allure-cypress";
 import "./commands";

package/templates/cypress-template/cypress/support/pages/README.md

@@ -0,0 +1,5 @@
+# Pages
+
+This folder holds Cypress page modules.
+
+- Keep selectors and reusable UI actions here instead of in spec files.

package/templates/cypress-template/cypress/support/pages/login-page.ts

@@ -1,3 +1,4 @@
+// Page module for the login screen used by custom Cypress commands.
 export const loginPage = {
   visit(): Cypress.Chainable {
     return cy.visit("/login");

package/templates/cypress-template/cypress/support/pages/people-page.ts

@@ -1,3 +1,4 @@
+// Page module for the people screen used in the starter Cypress journey.
 import type { PersonRecord } from "../data/data-factory";
 
 export const peoplePage = {

package/templates/cypress-template/cypress.config.ts

@@ -1,3 +1,7 @@
+// Central Cypress configuration for specs, retries, artifacts, and runtime env values.
+import * as os from "node:os";
+
+import { allureCypress } from "allure-cypress/reporter";
 import { defineConfig } from "cypress";
 
 import { loadRuntimeConfig } from "./config/runtime-config";
@@ -9,7 +13,19 @@ export default defineConfig({
     baseUrl: runtimeConfig.uiBaseUrl,
     specPattern: "cypress/e2e/**/*.cy.ts",
     supportFile: "cypress/support/e2e.ts",
-    setupNodeEvents(_on, config) {
+    setupNodeEvents(on, config) {
+      // Keep Cypress terminal output as the default path most users expect.
+      // Remove the Allure line below if you prefer to stay with Cypress output only.
+      allureCypress(on, config, {
+        resultsDir: "allure-results",
+        environmentInfo: {
+          os_platform: os.platform(),
+          os_release: os.release(),
+          os_version: os.version(),
+          node_version: process.version
+        }
+      });
+
       config.env = {
         ...config.env,
         testEnv: runtimeConfig.testEnv,

package/templates/cypress-template/eslint.config.mjs

@@ -22,7 +22,7 @@ const nodeGlobals = {
 
 export default [
   {
-    ignores: ["demo-apps/**", "node_modules/**", "reports/**"]
+    ignores: ["demo-apps/**", "node_modules/**", "reports/**", "allure-results/**", "allure-report/**"]
   },
   js.configs.recommended,
   {