@msalaam/xray-qe-toolkit 1.3.4 → 1.4.1

package/commands/importResults.js

@@ -1,20 +1,39 @@
 /**
- * Command: xqt import-results --file <path> [--testExecKey <key>]
+ * Command: xqt import-results --file <path> --env <environment>
  *
- * Imports test results into Xray Cloud and associates them with a Test Execution.
+ * Imports test execution results into Xray Cloud.
+ * Each invocation creates a NEW Test Execution — fresh execution per CI run.
  *
  * Supported formats:
- * - JUnit XML (.xml) - Standard JUnit or XUnit format
- * - Playwright JSON (.json) - Playwright JSON reporter output
+ *   - Playwright JSON (.json) — Playwright JSON reporter output
+ *   - JUnit XML (.xml)        — Standard JUnit / XUnit format
  *
- * Designed to run in CI — no human interaction required.
+ * The Xray JSON info object will include:
+ *   - testPlanKey (from .xrayrc or --plan flag)
+ *   - testEnvironments (from --env flag, default: defaultEnvironment from .xrayrc)
+ *   - version / revision (from --version / --revision flags)
+ *   - testExecutionKey (from --exec flag — import into a pre-created execution)
+ *
+ * Two modes:
+ *   AUTO:        xqt import-results --file results.json --env IOP-QA
+ *                → Xray auto-creates a new Test Execution from the results
+ *
+ *   PRE-CREATED: xqt create-execution --env IOP-QA  (get back APIEE-9876)
+ *                xqt import-results --file results.json --exec APIEE-9876
+ *                → Results imported into the existing execution
+ *
+ * Designed for CI — no human interaction required.
  */
 
 import fs from "node:fs";
 import path from "node:path";
 import logger, { setVerbose } from "../lib/logger.js";
 import { loadConfig, validateConfig } from "../lib/config.js";
-import { authenticate, importResults as importResultsXml, importResultsXrayJson } from "../lib/xrayClient.js";
+import {
+  authenticate,
+  importResultsMultipart,
+  importResults as importResultsXml,
+} from "../lib/xrayClient.js";
 import { convertPlaywrightToXray } from "../lib/playwrightConverter.js";
 
 export default async function importResults(opts = {}) {
@@ -25,6 +44,7 @@ export default async function importResults(opts = {}) {
   const cfg = loadConfig({ envPath: opts.env });
   validateConfig(cfg);
 
+  // ── Resolve file path ──────────────────────────────────────────────────────
   const filePath = path.resolve(opts.file);
   if (!fs.existsSync(filePath)) {
     logger.error(`Results file not found: ${filePath}`);
@@ -34,112 +54,125 @@ export default async function importResults(opts = {}) {
   const fileName = path.basename(filePath);
   const fileExt = path.extname(filePath).toLowerCase();
 
-  logger.info(`File: ${fileName}`);
-  if (opts.testExecKey) {
-    logger.info(`Test Execution: ${opts.testExecKey}`);
-  }
+  // ── Resolve environment ────────────────────────────────────────────────────
+  const environment = opts.environment || cfg.defaultEnvironment || "IOP-DEV";
+  const testEnvironments = [environment];
+
+  // ── Resolve plan key ───────────────────────────────────────────────────────
+  const planKey = opts.plan || cfg.testPlanKey;
+
+  // ── Resolve pre-created execution key ─────────────────────────────────────
+  const execKey = opts.exec || null;
+
+  // ── Summary info ──────────────────────────────────────────────────────────
+  logger.info(`File:        ${fileName}`);
+  logger.info(`Environment: ${environment}`);
+  if (execKey) logger.info(`Execution:   ${execKey} (pre-created)`);
+  if (planKey) logger.info(`Test Plan:   ${planKey}`);
+  if (opts.version) logger.info(`Version:     ${opts.version}`);
+  if (opts.revision) logger.info(`Revision:    ${opts.revision}`);
   logger.blank();
 
-  // Authenticate
+  // ── Authenticate ───────────────────────────────────────────────────────────
   const xrayToken = await authenticate(cfg);
 
-  // Detect format and import
+  // ── Build base Xray info object ────────────────────────────────────────────
+  const runTimestamp = new Date().toLocaleString();
+  const infoBase = {
+    summary: opts.summary || `${environment} Test Run — ${runTimestamp}`,
+    description: opts.description || `Automated test execution for ${environment}`,
+    testEnvironments,
+    // If a pre-created execution key is given, Xray will import INTO that execution
+    ...(execKey && { testExecutionKey: execKey }),
+    // Otherwise link to the plan (Xray will create a new execution under it)
+    ...(!execKey && planKey && { testPlanKey: planKey }),
+    ...(opts.version && { version: opts.version }),
+    ...(opts.revision && { revision: opts.revision }),
+  };
+
   let result;
+  let xrayJson;
 
-  if (fileExt === '.json') {
-    // Playwright JSON format
-    logger.send(`Converting Playwright results to Xray format...`);
+  if (fileExt === ".json") {
+    // ── Playwright JSON ────────────────────────────────────────────────────
+    logger.send("Converting Playwright results to Xray format...");
 
-    const playwrightJson = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    
-    // Convert to Xray format
-    const xrayJson = convertPlaywrightToXray(playwrightJson, {
-      testExecutionKey: opts.testExecKey,
+    const playwrightJson = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+
+    xrayJson = convertPlaywrightToXray(playwrightJson, {
       projectKey: cfg.jiraProjectKey,
-      summary: opts.summary || `Playwright Test Execution - ${new Date().toLocaleString()}`,
-      description: opts.description,
-      skipWithoutAnnotations: !!opts.testExecKey, // Skip tests without keys when updating existing execution
+      infoOverrides: infoBase,
     });
 
-    // Check if we have tests to upload
     if (xrayJson.tests.length === 0) {
-      logger.warn('⚠️  No tests with Xray annotations found.');
-      logger.info('\nAdd annotations to your tests:');
-      logger.info(`  test.info().annotations.push({ type: 'xray', description: 'APIEE-XXXX' });\n`);
+      logger.warn("No tests with Xray annotations found.");
+      logger.info("Add annotations to your Playwright tests:");
+      logger.info("  test.info().annotations.push({ type: 'xray', description: 'PROJ-1234' });");
       process.exit(0);
     }
 
-    const testsWithKeys = xrayJson.tests.filter(t => t.testKey).length;
-    const testsWithoutKeys = xrayJson.tests.filter(t => !t.testKey).length;
+    const withKeys = xrayJson.tests.filter((t) => t.testKey).length;
+    const withoutKeys = xrayJson.tests.length - withKeys;
 
-    logger.step(`Found ${testsWithKeys} test(s) with Xray annotations`);
-    
-    if (testsWithoutKeys > 0 && !opts.testExecKey) {
-      logger.info(`  ${testsWithoutKeys} test(s) without annotations will create new tests`);
-    } else if (testsWithoutKeys > 0 && opts.testExecKey) {
-      logger.warn(`  Skipped ${testsWithoutKeys} test(s) without annotations`);
-    }
+    logger.step(`${withKeys} test(s) with Xray keys, ${withoutKeys} without`);
 
-    // Save debug output if verbose
     if (opts.verbose) {
-      const debugPath = filePath.replace('.json', '-xray-debug.json');
+      const debugPath = filePath.replace(".json", "-xray-debug.json");
       fs.writeFileSync(debugPath, JSON.stringify(xrayJson, null, 2));
-      logger.info(`  Debug: Xray JSON saved to ${path.basename(debugPath)}`);
+      logger.info(`Debug Xray JSON saved to ${path.basename(debugPath)}`);
     }
     logger.blank();
 
-    // Import to Xray
-    logger.send(`Uploading ${xrayJson.tests.length} test result(s) to Xray...`);
-    result = await importResultsXrayJson(cfg, xrayToken, xrayJson);
+    logger.send(`Uploading ${xrayJson.tests.length} result(s) to Xray...`);
+    result = await importResultsMultipart(cfg, xrayToken, xrayJson);
   } else {
-    // JUnit XML format (default)
-    logger.send(`Importing JUnit XML results...`);
-
+    // ── JUnit XML ──────────────────────────────────────────────────────────
+    logger.send("Importing JUnit XML results...");
     const xmlBuffer = fs.readFileSync(filePath);
-    result = await importResultsXml(cfg, xrayToken, xmlBuffer, opts.testExecKey);
+    result = await importResultsXml(cfg, xrayToken, xmlBuffer, null, infoBase);
   }
 
   logger.success("Results imported successfully");
   logger.blank();
 
-  // Display summary for JSON results
-  if (fileExt === '.json' && xrayJson) {
-    const summaryStats = calculateTestSummary(xrayJson.tests);
-    
-    logger.info('Summary:');
-    logger.success(`  ✓ Passed:  ${summaryStats.passed}`)
-;
-    if (summaryStats.failed > 0) {
-      logger.error(`  ✗ Failed:  ${summaryStats.failed}`);
-    }
-    if (summaryStats.skipped > 0) {
-      logger.warn(`  ⊘ Skipped: ${summaryStats.skipped}`);
-    }
+  // ── Print summary ──────────────────────────────────────────────────────────
+  if (xrayJson?.tests) {
+    const stats = summarise(xrayJson.tests);
+    logger.info("Summary:");
+    logger.success(`  PASSED:  ${stats.passed}`);
+    if (stats.failed > 0) logger.error(`  FAILED:  ${stats.failed}`);
+    if (stats.skipped > 0) logger.warn(`  SKIPPED: ${stats.skipped}`);
     logger.blank();
   }
 
-  // Show link to Test Execution
-  if (result?.key) {
-    logger.link(`View: ${cfg.jiraUrl}/browse/${result.key}`);
-  } else if (result?.testExecIssue?.key) {
-    logger.link(`View: ${cfg.jiraUrl}/browse/${result.testExecIssue.key}`);
-  } else if (opts.testExecKey) {
-    logger.link(`View: ${cfg.jiraUrl}/browse/${opts.testExecKey}`);
+  // ── Show execution link ────────────────────────────────────────────────────
+  const resultKey =
+    execKey ||
+    result?.key ||
+    result?.testExecIssue?.key ||
+    result?.data?.key ||
+    null;
+
+  if (resultKey) {
+    logger.link(`Test Execution: ${cfg.jiraUrl}/browse/${resultKey}`);
+  }
+  if (planKey) {
+    logger.link(`Test Plan:      ${cfg.jiraUrl}/browse/${planKey}`);
   }
 
   logger.blank();
 }
 
 /**
- * Calculate test result summary
- * @param {array} tests - Xray test results
- * @returns {object} Summary stats
+ * Calculate test result summary from Xray test objects.
+ * @param {Array} tests
+ * @returns {{ passed: number, failed: number, skipped: number }}
  */
-function calculateTestSummary(tests) {
+function summarise(tests) {
   return {
-    passed: tests.filter(t => t.status === 'PASSED').length,
-    failed: tests.filter(t => t.status === 'FAILED').length,
-    skipped: tests.filter(t => t.status === 'SKIPPED').length,
-    total: tests.length,
+    passed: tests.filter((t) => t.status === "PASSED").length,
+    failed: tests.filter((t) => t.status === "FAILED").length,
+    skipped: tests.filter((t) => t.status === "SKIPPED").length,
   };
 }
+

package/commands/init.js

@@ -1,18 +1,36 @@
 /**
- * Command: xray-qe init
+ * Command: xqt init
  *
- * Scaffolds a new project with starter templates:
- *   - tests.json        (test definitions)
- *   - xray-mapping.json (empty mapping)
- *   - .env.example      (environment variable template)
- *   - .xrayrc           (optional project-level config)
+ * Scaffolds a per-repo QA test project structure.
+ * Idempotent — never overwrites existing files or folders.
+ *
+ * Creates:
+ *   .npmrc                          — npm registry config (ADO feed)
+ *   resources/                      — Spec + business rules root
+ *   resources/api-specs/            — OpenAPI / Swagger specifications
+ *   resources/api-specs/openapi.yaml — OpenAPI spec placeholder
+ *   resources/requirements/         — Business requirements & acceptance criteria
+ *   resources/tickets/              — Exported JIRA tickets & Confluence pages
+ *   resources/business-rules.yaml   — Business rules template
+ *   resources/README.md             — Resources folder guide
+ *   tests/models/                   — Data models, fixtures, payloads
+ *   tests/resources/                — Shared helpers, utilities, constants
+ *   tests/services/                 — Service-level test logic (setup/teardown)
+ *   tests/specs/                    — Playwright spec files
+ *   playwright.config.ts            — Pre-configured for JSON + JUnit reporters
+ *   tests.json                      — Test definitions
+ *   xray-mapping.json               — Empty mapping
+ *   .env.example                    — Credential template
+ *   .xrayrc                         — Project-level config
+ *   XQT-GUIDE.md                    — Comprehensive xqt usage guide
+ *   SPEC-DRIVEN-APPROACH.md         — Spec-driven QE process & workflow
+ *   azure-pipelines.yml             — ADO QA pipeline template
  */
 
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import logger from "../lib/logger.js";
-import { setVerbose } from "../lib/logger.js";
+import logger, { setVerbose } from "../lib/logger.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -27,19 +45,34 @@ export default async function init(opts = {}) {
   let created = 0;
   let skipped = 0;
 
-  // Create knowledge/ directory structure
-  const knowledgeDirs = [
-    { path: "knowledge", desc: "Knowledge base folder" },
-    { path: "knowledge/api-specs", desc: "API specifications (OpenAPI, Swagger)" },
-    { path: "knowledge/requirements", desc: "Business requirements and docs" },
-    { path: "knowledge/tickets", desc: "JIRA/Confluence exports" },
+  // ── Detect project name from package.json ─────────────────────────────────
+  let serviceName = path.basename(cwd);
+  try {
+    const pkgPath = path.join(cwd, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.name) serviceName = pkg.name.replace(/^@[^/]+\//, ""); // strip scope
+    }
+  } catch { /* best-effort */ }
+
+  // ── Directory structure ───────────────────────────────────────────────────
+  const directories = [
+    { path: "resources", desc: "API spec + business rules" },
+    { path: "resources/api-specs", desc: "OpenAPI / Swagger specifications" },
+    { path: "resources/requirements", desc: "Business requirements & acceptance criteria" },
+    { path: "resources/tickets", desc: "Exported JIRA tickets & Confluence pages" },
+    { path: "tests", desc: "Test root directory" },
+    { path: "tests/models", desc: "Data models, fixtures, payloads" },
+    { path: "tests/resources", desc: "Shared helpers, utilities, constants" },
+    { path: "tests/services", desc: "Service-level setup/teardown helpers" },
+    { path: "tests/specs", desc: "Playwright spec files" },
   ];
 
-  for (const dir of knowledgeDirs) {
+  for (const dir of directories) {
     const dirPath = path.join(cwd, dir.path);
     if (!fs.existsSync(dirPath)) {
       fs.mkdirSync(dirPath, { recursive: true });
-      logger.success(`${dir.path}/ created (${dir.desc})`);
+      logger.success(`${dir.path}/ created — ${dir.desc}`);
       created++;
     } else {
       logger.warn(`${dir.path}/ already exists — skipping`);
@@ -47,96 +80,251 @@ export default async function init(opts = {}) {
     }
   }
 
-  // Copy knowledge README
-  const knowledgeReadmeSrc = path.join(TEMPLATES, "knowledge-README.md");
-  const knowledgeReadmeDest = path.join(cwd, "knowledge", "README.md");
-  if (!fs.existsSync(knowledgeReadmeDest)) {
-    fs.copyFileSync(knowledgeReadmeSrc, knowledgeReadmeDest);
-    logger.success("knowledge/README.md created (Knowledge base guide)");
+  // .gitkeep files in leaf directories
+  for (const subdir of [
+    "resources/api-specs", "resources/requirements", "resources/tickets",
+    "tests/models", "tests/resources", "tests/services", "tests/specs",
+  ]) {
+    const gkPath = path.join(cwd, subdir, ".gitkeep");
+    if (!fs.existsSync(gkPath)) fs.writeFileSync(gkPath, "");
+  }
+
+  // ── .npmrc ────────────────────────────────────────────────────────────────
+  const npmrcDest = path.join(cwd, ".npmrc");
+  if (!fs.existsSync(npmrcDest)) {
+    fs.copyFileSync(path.join(TEMPLATES, ".npmrc"), npmrcDest);
+    logger.success(".npmrc created — npm registry config (ADO feed)");
     created++;
   } else {
-    logger.warn("knowledge/README.md already exists — skipping");
+    logger.warn(".npmrc already exists — skipping");
     skipped++;
   }
 
-  // Copy XQT guide — always written as XQT-GUIDE.md so the user's own README is never touched
-  const readmeSrc = path.join(TEMPLATES, "README.template.md");
-  const guideDest = path.join(cwd, "XQT-GUIDE.md");
-  if (!fs.existsSync(guideDest)) {
-    fs.copyFileSync(readmeSrc, guideDest);
-    logger.success("XQT-GUIDE.md created (Getting started guide)");
+  // ── resources/ files ─────────────────────────────────────────────────────
+  // OpenAPI spec placeholder
+  const openapiDest = path.join(cwd, "resources", "api-specs", "openapi.yaml");
+  if (!fs.existsSync(openapiDest)) {
+    fs.writeFileSync(openapiDest, [
+      `openapi: "3.0.3"`,
+      `info:`,
+      `  title: ${serviceName}`,
+      `  version: "1.0.0"`,
+      `  description: Replace this template with your actual OpenAPI specification.`,
+      `paths: {}`,
+    ].join("\n") + "\n");
+    logger.success("resources/api-specs/openapi.yaml created — OpenAPI spec placeholder");
     created++;
   } else {
-    logger.warn("XQT-GUIDE.md already exists — skipping");
+    logger.warn("resources/api-specs/openapi.yaml already exists — skipping");
     skipped++;
   }
 
-  // Create .gitkeep files in knowledge subdirs to ensure they're tracked
-  for (const subdir of ["api-specs", "requirements", "tickets"]) {
-    const gitkeepPath = path.join(cwd, "knowledge", subdir, ".gitkeep");
-    if (!fs.existsSync(gitkeepPath)) {
-      fs.writeFileSync(gitkeepPath, "");
-    }
+  // business-rules.yaml from template
+  const brSrc = path.join(TEMPLATES, "business-rules.yaml");
+  const brDest = path.join(cwd, "resources", "business-rules.yaml");
+  if (!fs.existsSync(brDest)) {
+    fs.copyFileSync(brSrc, brDest);
+    logger.success("resources/business-rules.yaml created — Business rules template");
+    created++;
+  } else {
+    logger.warn("resources/business-rules.yaml already exists — skipping");
+    skipped++;
   }
 
-  const files = [
-    { src: "tests.json", dest: "tests.json", desc: "Test definitions" },
-    { src: "xray-mapping.json", dest: "xray-mapping.json", desc: "Xray mapping (empty)" },
-  ];
+  // resources/README.md from template
+  const resReadmeDest = path.join(cwd, "resources", "README.md");
+  if (!fs.existsSync(resReadmeDest)) {
+    fs.copyFileSync(path.join(TEMPLATES, "resources-README.md"), resReadmeDest);
+    logger.success("resources/README.md created — Resources folder guide");
+    created++;
+  } else {
+    logger.warn("resources/README.md already exists — skipping");
+    skipped++;
+  }
 
-  for (const file of files) {
-    const destPath = path.join(cwd, file.dest);
-    if (fs.existsSync(destPath)) {
-      logger.warn(`${file.dest} already exists — skipping`);
-      skipped++;
-    } else {
-      fs.copyFileSync(path.join(TEMPLATES, file.src), destPath);
-      logger.success(`${file.dest} created (${file.desc})`);
-      created++;
-    }
+  // ── tests.json ────────────────────────────────────────────────────────────
+  const testsDest = path.join(cwd, "tests.json");
+  if (!fs.existsSync(testsDest)) {
+    fs.copyFileSync(path.join(TEMPLATES, "tests.json"), testsDest);
+    logger.success("tests.json created — Test definitions");
+    created++;
+  } else {
+    logger.warn("tests.json already exists — skipping");
+    skipped++;
+  }
+
+  // ── xray-mapping.json ─────────────────────────────────────────────────────
+  const mappingDest = path.join(cwd, "xray-mapping.json");
+  if (!fs.existsSync(mappingDest)) {
+    fs.copyFileSync(path.join(TEMPLATES, "xray-mapping.json"), mappingDest);
+    logger.success("xray-mapping.json created — Xray ID mapping (empty)");
+    created++;
+  } else {
+    logger.warn("xray-mapping.json already exists — skipping");
+    skipped++;
+  }
+
+  // ── playwright.config.ts ──────────────────────────────────────────────────
+  const playwrightConfigDest = path.join(cwd, "playwright.config.ts");
+  if (!fs.existsSync(playwrightConfigDest)) {
+    fs.writeFileSync(playwrightConfigDest, generatePlaywrightConfig(serviceName));
+    logger.success("playwright.config.ts created — Playwright config (JSON + JUnit reporters)");
+    created++;
+  } else {
+    logger.warn("playwright.config.ts already exists — skipping");
+    skipped++;
   }
 
-  // Copy .env.example from package root
+  // ── .env.example ─────────────────────────────────────────────────────────
   const envExampleSrc = path.join(__dirname, "..", ".env.example");
   const envExampleDest = path.join(cwd, ".env.example");
   if (!fs.existsSync(envExampleDest)) {
     fs.copyFileSync(envExampleSrc, envExampleDest);
-    logger.success(".env.example created");
+    logger.success(".env.example created — Credential template");
     created++;
   } else {
     logger.warn(".env.example already exists — skipping");
     skipped++;
   }
 
-  // Create .xrayrc if it doesn't exist
+  // ── .xrayrc ───────────────────────────────────────────────────────────────
   const xrayrcPath = path.join(cwd, ".xrayrc");
   if (!fs.existsSync(xrayrcPath)) {
     const xrayrc = {
       testsPath: "tests.json",
       mappingPath: "xray-mapping.json",
-      playwrightResultsPath: "playwright-results.json",
-      knowledgePath: "knowledge",
-      playwrightDir: "playwright-tests",
+      resourcesPath: "resources",
+      playwrightDir: "tests",
+      testPlanKey: "",
+      defaultEnvironment: "IOP-DEV",
+      environments: ["IOP-DEV", "IOP-QA", "IOP-PROD"],
+      folderRoot: `/${serviceName}`,
+      xrayRegion: "us",
     };
     fs.writeFileSync(xrayrcPath, JSON.stringify(xrayrc, null, 2));
-    logger.success(".xrayrc created (project config)");
+    logger.success(".xrayrc created — Project config");
     created++;
   } else {
     logger.warn(".xrayrc already exists — skipping");
     skipped++;
   }
 
-  logger.success(`${created} file(s)/folder(s) created, ${skipped} skipped\n`);
-
-  // Print next steps
-  console.log("📖 Next steps:");
-  console.log("   1. Copy .env.example → .env and fill in your credentials");
-  console.log("   2. Add API specs and docs to knowledge/ folder (see knowledge/README.md)");
-  console.log("   3. See XQT-GUIDE.md for the full workflow and command reference");
-  console.log("   4. Generate test cases: npx xray-qe gen-tests --ai (or edit tests.json manually)");
-  console.log("   5. Review tests: npx xray-qe edit-json");
-  console.log("   6. Push tests to Xray: npx xray-qe push-tests");
-  console.log("   7. Generate CI pipeline: npx xqt gen-pipeline");
-  console.log("   8. Run Playwright tests and import results: npx xqt import-results --file playwright-results.json");
-  console.log("");
+  // ── XQT-GUIDE.md ─────────────────────────────────────────────────────────
+  const guideDest = path.join(cwd, "XQT-GUIDE.md");
+  const guideSrc = path.join(TEMPLATES, "README.template.md");
+  if (!fs.existsSync(guideDest)) {
+    let guideContent = fs.readFileSync(guideSrc, "utf8");
+    // Replace {{SERVICE_NAME}} placeholder
+    guideContent = guideContent.replace(/\{\{SERVICE_NAME\}\}/g, serviceName);
+    fs.writeFileSync(guideDest, guideContent);
+    logger.success("XQT-GUIDE.md created — Comprehensive usage guide");
+    created++;
+  } else {
+    logger.warn("XQT-GUIDE.md already exists — skipping");
+    skipped++;
+  }
+  // ── SPEC-DRIVEN-APPROACH.md ───────────────────────────────────────────────
+  const specDrivenDest = path.join(cwd, "SPEC-DRIVEN-APPROACH.md");
+  const specDrivenSrc = path.join(TEMPLATES, "SPEC-DRIVEN-APPROACH.md");
+  if (!fs.existsSync(specDrivenDest)) {
+    let specContent = fs.readFileSync(specDrivenSrc, "utf8");
+    specContent = specContent.replace(/\{\{SERVICE_NAME\}\}/g, serviceName);
+    fs.writeFileSync(specDrivenDest, specContent);
+    logger.success("SPEC-DRIVEN-APPROACH.md created — QE process & workflow guide");
+    created++;
+  } else {
+    logger.warn("SPEC-DRIVEN-APPROACH.md already exists — skipping");
+    skipped++;
+  }
+
+  // ── azure-pipelines.yml ───────────────────────────────────────────────────
+  const pipelineDest = path.join(cwd, "azure-pipelines.yml");
+  const pipelineSrc = path.join(TEMPLATES, "azure-pipelines.yml");
+  if (!fs.existsSync(pipelineDest)) {
+    let pipelineContent = fs.readFileSync(pipelineSrc, "utf8");
+    pipelineContent = pipelineContent.replace(/\{\{SERVICE_NAME\}\}/g, serviceName);
+    fs.writeFileSync(pipelineDest, pipelineContent);
+    logger.success(`azure-pipelines.yml created — ADO QA pipeline (variable group: ${serviceName}-qa)`);
+    created++;
+  } else {
+    logger.warn("azure-pipelines.yml already exists — skipping");
+    skipped++;
+  }
+
+  // ── Summary ───────────────────────────────────────────────────────────────
+  logger.blank();
+  logger.success(`Init complete: ${created} item(s) created, ${skipped} skipped`);
+  logger.blank();
+
+  console.log("Next steps:");
+  console.log("  1. Copy .env.example → .env and fill in your credentials for local development");
+  console.log("     (XRAY_ID, XRAY_SECRET, JIRA_PROJECT_KEY, JIRA_URL, JIRA_API_TOKEN, JIRA_EMAIL)");
+  console.log("  2. Add your OpenAPI spec to resources/openapi.yaml");
+  console.log("  3. Define business rules in resources/business-rules.yaml");
+  console.log("  4. In ADO Library, ensure these variable groups exist:");
+  console.log(`     - xray-qa-shared          (shared): xray_client_id, xray_client_secret,`);
+  console.log("                                          JIRA_PROJECT_KEY, JIRA_URL,");
+  console.log("                                          JIRA_API_TOKEN, JIRA_EMAIL,");
+  console.log("                                          XRAY_GRAPHQL_URL_US, XRAY_REST_URL");
+  console.log(`     - ${serviceName}-qa  (per-repo): base_url, gravitee_api_key`);
+  console.log("  5. Register azure-pipelines.yml in ADO Pipelines (trigger: manual for regression)");
+  console.log("  6. Create a Test Plan: npx xqt create-plan --summary 'My Service Tests'");
+  console.log("     then update the testPlanKey in .xrayrc");
+  console.log("  7. Use Copilot + SPEC-DRIVEN-APPROACH.md to generate tests from your spec files");
+  console.log("  8. Push tests to Xray: npx xqt push-tests");
+  console.log("  9. Run tests and import results: npx xqt import-results --file test-results/results.json");
+  console.log("  📖 See XQT-GUIDE.md for the xqt command reference");
+  console.log("  📋 See SPEC-DRIVEN-APPROACH.md for the full QE process\n");
+}
+
+// ─── Generators ───────────────────────────────────────────────────────────────
+
+function generatePlaywrightConfig(serviceName) {
+  return `import { defineConfig, devices } from '@playwright/test';
+import * as path from 'path';
+
+/**
+ * Playwright configuration for ${serviceName}
+ * Generated by @msalaam/xray-qe-toolkit
+ *
+ * Reporters:
+ *   - JSON      → test-results/results.json  (consumed by xqt import-results)
+ *   - JUnit XML → test-results/results.xml   (consumed by xqt import-results --file results.xml)
+ *   - HTML      → playwright-report/         (artifact in CI)
+ */
+export default defineConfig({
+  testDir: './tests/specs',
+  outputDir: './test-results/artifacts',
+  timeout: 30000,
+  retries: process.env.CI ? 1 : 0,
+  workers: process.env.CI ? 2 : undefined,
+  fullyParallel: false,
+
+  reporter: [
+    ['json', { outputFile: 'test-results/results.json' }],
+    ['junit', { outputFile: 'test-results/results.xml' }],
+    ['html', { outputFolder: 'playwright-report', open: 'never' }],
+  ],
+
+  use: {
+    baseURL: process.env.BASE_URL || 'http://localhost:3000',
+    trace: 'retain-on-failure',
+    screenshot: 'only-on-failure',
+  },
+
+  projects: [
+    {
+      name: 'api',
+      use: {
+        ...devices['Desktop Chrome'],
+      },
+    },
+  ],
+});
+`;
 }
+
+
+
+
+