@qa-gentic/stlc-agents 1.0.5 → 1.0.7

package/src/cli/cmd-init.js

@@ -0,0 +1,145 @@
+/**
+ * cmd-init.js — `qa-stlc init`
+ *
+ * Full bootstrap: install Python agents + skills + MCP config.
+ * Accepts --integration <ado|jira|both>.  When omitted, reads
+ * ~/.qa-stlc/integration (written by postinstall) or prompts interactively.
+ */
+"use strict";
+
+const { execSync, spawnSync } = require("child_process");
+const path = require("path");
+const fs   = require("fs");
+const os   = require("os");
+
+const cmdSkills       = require("./cmd-skills");
+const cmdMcpConfig    = require("./cmd-mcp-config");
+const pickIntegration = require("./prompt-integration");
+
+const PREF_FILE = path.join(os.homedir(), ".qa-stlc", "integration");
+
+function readSavedIntegration() {
+  try {
+    if (fs.existsSync(PREF_FILE)) return fs.readFileSync(PREF_FILE, "utf8").trim();
+  } catch (_) {}
+  return null;
+}
+
+function saveIntegration(value) {
+  try {
+    fs.mkdirSync(path.dirname(PREF_FILE), { recursive: true });
+    fs.writeFileSync(PREF_FILE, value, "utf8");
+  } catch (_) {}
+}
+
+const C = {
+  reset: "\x1b[0m", bold: "\x1b[1m",
+  green: "\x1b[32m", cyan: "\x1b[36m",
+  yellow: "\x1b[33m", red: "\x1b[31m", dim: "\x1b[2m",
+};
+const ok   = (m) => console.log(`${C.green}✓${C.reset}  ${m}`);
+const info = (m) => console.log(`${C.cyan}→${C.reset}  ${m}`);
+const warn = (m) => console.log(`${C.yellow}⚠${C.reset}  ${m}`);
+const die  = (m) => { console.error(`${C.red}✗${C.reset}  ${m}`); process.exit(1); };
+
+module.exports = async function init(opts) {
+  console.log(`\n${C.bold}QA STLC Agents — init${C.reset}\n`);
+
+  // ── 1. Check Python ──────────────────────────────────────────────────────
+  const python = opts.python || "python3";
+  info(`Checking Python (${python})…`);
+  const pyCheck = spawnSync(python, ["--version"], { encoding: "utf8" });
+  if (pyCheck.status !== 0) {
+    die(`Python not found at '${python}'. Install Python 3.10+ or pass --python <path>.`);
+  }
+  const pyVersion = (pyCheck.stdout || pyCheck.stderr || "").trim();
+  const match = pyVersion.match(/Python (\d+)\.(\d+)/);
+  if (!match || parseInt(match[1]) < 3 || parseInt(match[2]) < 10) {
+    die(`Python 3.10+ required, found: ${pyVersion}`);
+  }
+  ok(`${pyVersion} found.`);
+
+  // ── 2. Resolve integration choice ────────────────────────────────────────
+  // Priority: --integration flag > saved preference > interactive prompt
+  let integration = (opts.integration || "").toLowerCase().trim();
+  const validIntegrations = ["ado", "jira", "both"];
+  if (integration && !validIntegrations.includes(integration)) {
+    die(`Invalid --integration value: "${integration}". Use ado, jira, or both.`);
+  }
+  if (!integration) {
+    integration = readSavedIntegration();
+  }
+  if (!integration) {
+    integration = await pickIntegration("ado");
+  }
+  saveIntegration(integration);
+
+  const needsAdo  = integration === "ado"  || integration === "both";
+  const needsJira = integration === "jira" || integration === "both";
+  info(`Integration: ${C.bold}${integration}${C.reset}`);
+
+  // ── 3. pip install qa-gentic-stlc-agents ──────────────────────────────────
+  info("Installing qa-gentic-stlc-agents (pip)…");
+  const pip = spawnSync(python, ["-m", "pip", "install", "qa-gentic-stlc-agents>=1.0.1", "--quiet"], {
+    stdio: "inherit",
+    encoding: "utf8",
+  });
+  if (pip.status !== 0) {
+    die("pip install failed. Run manually: pip install qa-gentic-stlc-agents");
+  }
+  ok("qa-gentic-stlc-agents installed.");
+
+  // ── 4. Install skills ─────────────────────────────────────────────────────
+  info("Installing skills…");
+  const skillTarget = opts.vscode ? "both" : "claude";
+  await cmdSkills({ target: skillTarget, integration });
+
+  // ── 5. Write MCP config ───────────────────────────────────────────────────
+  info("Writing MCP config…");
+  await cmdMcpConfig({
+    vscode:         opts.vscode || false,
+    print:          false,
+    python:         python,
+    playwrightPort: "8931",
+    integration,
+  });
+
+  // ── 6. Done ───────────────────────────────────────────────────────────────
+  const mcpLocation    = opts.vscode ? ".vscode/mcp.json" : ".mcp.json";
+  const skillsLocation = opts.vscode
+    ? ".github/copilot-instructions/  (reload VS Code window to activate)"
+    : ".claude/skills/";
+
+  const adoSection = needsAdo ? `
+  ${C.dim}ADO pipeline:${C.reset}
+  ${C.dim}1 →${C.reset} ${C.yellow}qa-test-case-manager${C.reset}     ${C.dim}ADO work item → manual test cases${C.reset}
+  ${C.dim}2 →${C.reset} ${C.yellow}qa-gherkin-generator${C.reset}     ${C.dim}Epic / Feature / PBI → .feature file${C.reset}
+  ${C.dim}3 →${C.reset} ${C.yellow}qa-playwright-generator${C.reset}  ${C.dim}Gherkin + live browser → self-healing Playwright${C.reset}
+  ${C.dim}4 →${C.reset} ${C.yellow}qa-helix-writer${C.reset}          ${C.dim}Generated files → Helix-QA project${C.reset}` : "";
+
+  const jiraSection = needsJira ? `
+  ${C.dim}Jira pipeline:${C.reset}
+  ${C.dim}1 →${C.reset} ${C.yellow}qa-jira-manager${C.reset}          ${C.dim}Fetch Jira issue + analyse acceptance criteria${C.reset}
+  ${C.dim}2 →${C.reset} ${C.yellow}qa-jira-manager${C.reset}          ${C.dim}Generate test cases → create in Jira with 'is tested by' links${C.reset}
+  ${C.dim}3 →${C.reset} ${C.yellow}qa-gherkin-generator${C.reset}     ${C.dim}Generate Gherkin .feature file from Jira issue AC${C.reset}
+  ${C.dim}4 →${C.reset} ${C.yellow}qa-playwright-generator${C.reset}  ${C.dim}Gherkin + live browser → self-healing Playwright TypeScript${C.reset}
+  ${C.dim}5 →${C.reset} ${C.yellow}qa-helix-writer${C.reset}          ${C.dim}Generated files → Helix-QA project on disk${C.reset}
+  ${C.dim}   Requires: JIRA_CLIENT_ID + JIRA_CLIENT_SECRET + JIRA_CLOUD_ID in .env${C.reset}` : "";
+
+  console.log(`
+${C.bold}Setup complete.${C.reset}
+
+  ${C.dim}Integration:${C.reset} ${C.bold}${integration}${C.reset}
+  ${C.dim}MCP config :${C.reset} ${mcpLocation}
+  ${C.dim}Skills     :${C.reset} ${skillsLocation}
+
+${C.bold}Start Playwright MCP${C.reset} ${C.dim}(keep running in a separate terminal):${C.reset}
+
+  ${C.cyan}npx @playwright/mcp@latest --port 8931${C.reset}
+
+${C.bold}STLC Workflow:${C.reset}
+${adoSection}${jiraSection}
+
+${C.dim}Change integration at any time:  qa-stlc init --integration <ado|jira|both>${C.reset}
+`);
+};

package/src/{cmd-mcp-config.js → cli/cmd-mcp-config.js}

@@ -18,6 +18,19 @@ const ok   = (m) => console.log(`${C.green}✓${C.reset}  ${m}`);
 const info = (m) => console.log(`${C.cyan}→${C.reset}  ${m}`);
 const warn = (m) => console.log(`${C.yellow}⚠${C.reset}  ${m}`);
 
+const os   = require("os");
+const fs_  = fs;  // alias — fs already required above
+
+const PREF_FILE_MCP = require("path").join(os.homedir(), ".qa-stlc", "integration");
+
+function readIntegrationPref() {
+  try {
+    if (fs_.existsSync(PREF_FILE_MCP))
+      return fs_.readFileSync(PREF_FILE_MCP, "utf8").trim();
+  } catch (_) {}
+  return "ado";
+}
+
 const CWD = process.cwd();
 const IS_WIN = process.platform === "win32";
 const EXT = IS_WIN ? ".exe" : "";
@@ -29,6 +42,14 @@ const AGENT_NAMES = [
   "qa-helix-writer",
 ];
 
+// Jira agent — added separately because it needs env var injection
+const JIRA_AGENT_NAME = "qa-jira-manager";
+const JIRA_ENV_VARS = {
+  JIRA_CLIENT_ID:     "${env:JIRA_CLIENT_ID}",
+  JIRA_CLIENT_SECRET: "${env:JIRA_CLIENT_SECRET}",
+  JIRA_CLOUD_ID:      "${env:JIRA_CLOUD_ID}",
+};
+
 /**
  * Locate the binary for an agent.
  * Priority: .venv → --python dir → system PATH → python sys.executable dir → macOS framework dirs
@@ -76,11 +97,18 @@ function findBinary(name, pythonBin) {
   return null;
 }
 
-function buildClaudeConfig(pythonBin, playwrightPort) {
+function buildClaudeConfig(pythonBin, playwrightPort, integration) {
   const servers = {};
   const missing = [];
+  const needsAdo  = !integration || integration === "ado"  || integration === "both";
+  const needsJira = integration === "jira" || integration === "both";
 
-  for (const name of AGENT_NAMES) {
+  // ADO agents — always included for ado/both; also included for jira because
+  // qa-gherkin-generator, qa-playwright-generator, and qa-helix-writer are shared
+  // by the Jira pipeline (Gherkin → Playwright → Helix steps run the same agents).
+  const activeNames = (needsAdo || needsJira) ? AGENT_NAMES : [];
+
+  for (const name of activeNames) {
     const bin = findBinary(name, pythonBin);
     if (bin) {
       servers[name] = { command: bin };
@@ -90,6 +118,21 @@ function buildClaudeConfig(pythonBin, playwrightPort) {
     }
   }
 
+  // Jira agent — only when integration includes jira
+  if (needsJira) {
+    const jiraBin = findBinary(JIRA_AGENT_NAME, pythonBin);
+    if (jiraBin) {
+      servers[JIRA_AGENT_NAME] = { command: jiraBin, env: JIRA_ENV_VARS };
+    } else {
+      missing.push(JIRA_AGENT_NAME);
+      servers[JIRA_AGENT_NAME] = {
+        command: `/path/to/.venv/bin/${JIRA_AGENT_NAME}`,
+        env: JIRA_ENV_VARS,
+        "_comment": "NOT FOUND — run: pip install qa-gentic-stlc-agents",
+      };
+    }
+  }
+
   servers["playwright"] = {
     type: "url",
     url: `ws://localhost:${playwrightPort}`,
@@ -98,11 +141,15 @@ function buildClaudeConfig(pythonBin, playwrightPort) {
   return { config: { mcpServers: servers }, missing };
 }
 
-function buildVscodeConfig(pythonBin, playwrightPort) {
+function buildVscodeConfig(pythonBin, playwrightPort, integration) {
   const servers = {};
   const missing = [];
+  const needsAdo  = !integration || integration === "ado"  || integration === "both";
+  const needsJira = integration === "jira" || integration === "both";
+  // Shared agents (Gherkin, Playwright, Helix) are needed by both ADO and Jira pipelines.
+  const activeNames = (needsAdo || needsJira) ? AGENT_NAMES : [];
 
-  for (const name of AGENT_NAMES) {
+  for (const name of activeNames) {
     const bin = findBinary(name, pythonBin);
     if (bin) {
       servers[name] = { command: bin };
@@ -112,6 +159,21 @@ function buildVscodeConfig(pythonBin, playwrightPort) {
     }
   }
 
+  // Jira agent — only when integration includes jira
+  if (needsJira) {
+    const jiraBinV = findBinary(JIRA_AGENT_NAME, pythonBin);
+    if (jiraBinV) {
+      servers[JIRA_AGENT_NAME] = { command: jiraBinV, env: JIRA_ENV_VARS };
+    } else {
+      missing.push(JIRA_AGENT_NAME);
+      servers[JIRA_AGENT_NAME] = {
+        command: `/path/to/.venv/bin/${JIRA_AGENT_NAME}`,
+        env: JIRA_ENV_VARS,
+        "_comment": "NOT FOUND — run: pip install qa-gentic-stlc-agents",
+      };
+    }
+  }
+
   servers["playwright"] = {
     type: "http",
     url: `http://localhost:${playwrightPort}/mcp`,
@@ -139,10 +201,11 @@ module.exports = async function mcpConfig(opts) {
   const printOnly      = opts.print  || false;
   const pythonBin      = opts.python || "python3";
   const playwrightPort = opts.playwrightPort || "8931";
+  const integration    = (opts.integration || readIntegrationPref() || "ado").toLowerCase();
 
   if (printOnly) {
-    const { config: claudeCfg } = buildClaudeConfig(pythonBin, playwrightPort);
-    const { config: vscodeCfg } = buildVscodeConfig(pythonBin, playwrightPort);
+    const { config: claudeCfg } = buildClaudeConfig(pythonBin, playwrightPort, integration);
+    const { config: vscodeCfg } = buildVscodeConfig(pythonBin, playwrightPort, integration);
     console.log("\n=== Claude Code (.mcp.json) ===");
     console.log(JSON.stringify(claudeCfg, null, 2));
     console.log("\n=== VS Code (.vscode/mcp.json) ===");
@@ -152,7 +215,7 @@ module.exports = async function mcpConfig(opts) {
   }
 
   if (useVscode) {
-    const { config, missing } = buildVscodeConfig(pythonBin, playwrightPort);
+    const { config, missing } = buildVscodeConfig(pythonBin, playwrightPort, integration);
     const dir = path.join(CWD, ".vscode");
     fs.mkdirSync(dir, { recursive: true });
     const out = path.join(dir, "mcp.json");
@@ -164,7 +227,7 @@ module.exports = async function mcpConfig(opts) {
     }
     printNextSteps("vscode", playwrightPort);
   } else {
-    const { config, missing } = buildClaudeConfig(pythonBin, playwrightPort);
+    const { config, missing } = buildClaudeConfig(pythonBin, playwrightPort, integration);
     const out = path.join(CWD, ".mcp.json");
     fs.writeFileSync(out, JSON.stringify(config, null, 2) + "\n", "utf8");
     ok(`Written → .mcp.json`);
@@ -174,4 +237,4 @@ module.exports = async function mcpConfig(opts) {
     }
     printNextSteps("claude", playwrightPort);
   }
-};
+};

package/src/cli/cmd-skills.js

@@ -0,0 +1,209 @@
+/**
+ * cmd-skills.js — `qa-stlc skills`
+ *
+ * Copies skill markdown files into the correct directory for each coding agent:
+ *
+ *   claude    →  .claude/skills/  +  .claude/AGENT-BEHAVIOR.md
+ *   vscode    →  .github/copilot-instructions/
+ *   cursor    →  .cursor/rules/ (one file per skill)
+ *   windsurf  →  .windsurf/rules/
+ *   both      →  claude + vscode
+ *   print     →  stdout only
+ */
+"use strict";
+
+const path = require("path");
+const fs   = require("fs");
+
+const C = {
+  reset: "\x1b[0m", bold: "\x1b[1m",
+  green: "\x1b[32m", yellow: "\x1b[33m", dim: "\x1b[2m",
+};
+const ok   = (m) => console.log(`${C.green}✓${C.reset}  ${m}`);
+const info = (m) => console.log(`   ${C.dim}${m}${C.reset}`);
+const warn = (m) => console.log(`${C.yellow}⚠${C.reset}  ${m}`);
+
+const os = require("os");
+const PREF_FILE_SK = require("path").join(os.homedir(), ".qa-stlc", "integration");
+
+function readIntegrationPrefSk() {
+  try {
+    if (fs.existsSync(PREF_FILE_SK))
+      return fs.readFileSync(PREF_FILE_SK, "utf8").trim();
+  } catch (_) {}
+  return "ado";
+}
+
+// Resolve the skills bundled with this npm package
+const PKG_ROOT    = path.resolve(__dirname, "..");
+const SKILLS_DIR  = path.join(PKG_ROOT, "skills");
+const BEHAVIOR_MD = path.join(SKILLS_DIR, "AGENT-BEHAVIOR.md");
+const AGENTS_DIR  = path.join(PKG_ROOT, ".github", "agents");
+
+/** Copy a file, creating parent dirs as needed. */
+function cp(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+/**
+ * List skill directories (each containing a SKILL.md), filtered by integration.
+ * Returns objects: { name, skillMd, dir }
+ */
+function skillEntries(integration) {
+  const integ = integration || readIntegrationPrefSk() || "ado";
+  const includeJira = integ === "jira" || integ === "both";
+  const adoOnlySkills = new Set(["generate-test-cases"]);
+  return fs.readdirSync(SKILLS_DIR)
+    .filter((entry) => {
+      // Only directories with a SKILL.md
+      const skillMd = path.join(SKILLS_DIR, entry, "SKILL.md");
+      if (!fs.existsSync(skillMd)) return false;
+      // Jira skill — only when integration includes jira
+      if (entry === "qa-jira-manager" && !includeJira) return false;
+      // ADO-only skills — exclude when integration is jira-only
+      if (adoOnlySkills.has(entry) && integ === "jira") return false;
+      return true;
+    })
+    .map((entry) => ({
+      name: entry,
+      skillMd: path.join(SKILLS_DIR, entry, "SKILL.md"),
+      dir: path.join(SKILLS_DIR, entry),
+    }));
+}
+
+/** Back-compat: returns array of SKILL.md paths (used for print/count). */
+function skillFiles(integration) {
+  return skillEntries(integration).map((e) => e.skillMd);
+}
+
+const CWD = process.cwd();
+
+/** List .agent.md files, filtered by integration. */
+function agentFiles(integration) {
+  const integ = integration || readIntegrationPrefSk() || "ado";
+  const includeJira = integ === "jira" || integ === "both";
+  const adoOnlyAgents = new Set(["qa-test-case-manager.agent.md"]);
+  return fs.readdirSync(AGENTS_DIR)
+    .filter((f) => {
+      if (!f.endsWith(".agent.md")) return false;
+      if (f === "qa-jira-manager.agent.md" && !includeJira) return false;
+      if (adoOnlyAgents.has(f) && integ === "jira") return false;
+      return true;
+    })
+    .map((f) => path.join(AGENTS_DIR, f));
+}
+
+/** Install .agent.md files to .github/agents/ in the consumer project. */
+function installAgents(integration) {
+  if (!fs.existsSync(AGENTS_DIR)) return;
+  const dest = path.join(CWD, ".github", "agents");
+  for (const src of agentFiles(integration)) {
+    cp(src, path.join(dest, path.basename(src)));
+  }
+  ok(`Agent files installed → .github/agents/`);
+  agentFiles(integration).forEach((f) => info(path.basename(f)));
+}
+
+function installClaude(integration) {
+  const dest = path.join(CWD, ".claude", "skills");
+  // Copy entire skill directory (preserves references/ subdirectory)
+  for (const entry of skillEntries(integration)) {
+    const targetDir = path.join(dest, entry.name);
+    fs.mkdirSync(targetDir, { recursive: true });
+    copyDirRecursive(entry.dir, targetDir);
+  }
+  cp(BEHAVIOR_MD, path.join(CWD, ".claude", "AGENT-BEHAVIOR.md"));
+  ok(`Skills installed → .claude/skills/`);
+  info("AGENT-BEHAVIOR.md → .claude/AGENT-BEHAVIOR.md");
+  skillEntries(integration).forEach((e) => info(`${e.name}/SKILL.md`));
+  installAgents(integration);
+  printPlaywrightHint();
+}
+
+function installVscode(integration) {
+  const dest = path.join(CWD, ".github", "copilot-instructions");
+  // Flat copy: SKILL.md → <name>.md
+  for (const entry of skillEntries(integration)) {
+    cp(entry.skillMd, path.join(dest, `${entry.name}.md`));
+  }
+  cp(BEHAVIOR_MD, path.join(dest, "AGENT-BEHAVIOR.md"));
+  ok(`Skills installed → .github/copilot-instructions/`);
+  info("Add to .github/copilot-instructions.md:");
+  info("  @.github/copilot-instructions/AGENT-BEHAVIOR.md");
+  installAgents(integration);
+  printPlaywrightHint();
+}
+
+function installCursor(integration) {
+  const dest = path.join(CWD, ".cursor", "rules");
+  // Flat copy: SKILL.md → <name>.md
+  for (const entry of skillEntries(integration)) {
+    cp(entry.skillMd, path.join(dest, `${entry.name}.md`));
+  }
+  cp(BEHAVIOR_MD, path.join(dest, "AGENT-BEHAVIOR.md"));
+  ok(`Skills installed → .cursor/rules/`);
+  printPlaywrightHint();
+}
+
+function installWindsurf(integration) {
+  const dest = path.join(CWD, ".windsurf", "rules");
+  // Flat copy: SKILL.md → <name>.md
+  for (const entry of skillEntries(integration)) {
+    cp(entry.skillMd, path.join(dest, `${entry.name}.md`));
+  }
+  cp(BEHAVIOR_MD, path.join(dest, "AGENT-BEHAVIOR.md"));
+  ok(`Skills installed → .windsurf/rules/`);
+  printPlaywrightHint();
+}
+
+function printSkills() {
+  console.log("\nAvailable skills:\n");
+  skillEntries().forEach((e) => console.log(`  ${e.name}/SKILL.md`));
+  console.log(`  AGENT-BEHAVIOR.md`);
+}
+
+/** Recursively copy a directory tree. */
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath  = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function printPlaywrightHint() {
+  console.log(`
+  ${C.dim}Start Playwright MCP before running generation workflows:${C.reset}
+  npx @playwright/mcp@latest --port 8931
+`);
+}
+
+module.exports = async function skills(opts) {
+  const target = (opts.target || "claude").toLowerCase();
+
+  if (!fs.existsSync(SKILLS_DIR)) {
+    console.error(`Skills directory not found: ${SKILLS_DIR}`);
+    console.error("Try reinstalling: npm install -g @qa-stlc/agents");
+    process.exit(1);
+  }
+
+  const integ = opts.integration || readIntegrationPrefSk() || "ado";
+  switch (target) {
+    case "claude":  installClaude(integ);  break;
+    case "vscode":  installVscode(integ);  break;
+    case "cursor":  installCursor(integ);  break;
+    case "windsurf": installWindsurf(integ); break;
+    case "both":    installClaude(integ); installVscode(integ); break;
+    case "print":   printSkills();   break;
+    default:
+      warn(`Unknown target: ${target}`);
+      warn("Valid targets: claude, vscode, cursor, windsurf, both, print");
+      process.exit(1);
+  }
+};

package/src/{cmd-verify.js → cli/cmd-verify.js}

@@ -24,6 +24,16 @@ const fail = (m) => console.log(`  ${C.red}✗${C.reset}  ${m}`);
 const warn = (m) => console.log(`  ${C.yellow}⚠${C.reset}  ${m}`);
 const head = (m) => console.log(`\n${C.bold}${m}${C.reset}`);
 
+const PREF_FILE_V = require("path").join(os.homedir(), ".qa-stlc", "integration");
+
+function readIntegrationPrefV() {
+  try {
+    if (fs.existsSync(PREF_FILE_V))
+      return fs.readFileSync(PREF_FILE_V, "utf8").trim();
+  } catch (_) {}
+  return "ado";
+}
+
 const CWD    = process.cwd();
 const IS_WIN = process.platform === "win32";
 const EXT    = IS_WIN ? ".exe" : "";
@@ -33,6 +43,7 @@ const AGENT_NAMES = [
   "qa-gherkin-generator",
   "qa-playwright-generator",
   "qa-helix-writer",
+  "qa-jira-manager",
 ];
 
 function findBinary(name) {
@@ -63,8 +74,17 @@ module.exports = async function verify(opts) {
   let allOk = true;
 
   // ── 1. Python agents ──────────────────────────────────────────────────────
-  head("Python MCP Agents");
-  for (const name of AGENT_NAMES) {
+  const integration = (opts.integration || readIntegrationPrefV() || "ado").toLowerCase();
+  const needsAdo  = integration === "ado"  || integration === "both";
+  const needsJira = integration === "jira" || integration === "both";
+  // Shared agents (Gherkin, Playwright, Helix) are required by both ADO and Jira pipelines.
+  const activeNames = [
+    ...((needsAdo || needsJira) ? AGENT_NAMES : []),
+    ...(needsJira ? ["qa-jira-manager"] : []),
+  ].filter((v, i, a) => a.indexOf(v) === i); // deduplicate for 'both' case
+
+  head(`Python MCP Agents  (integration: ${C.bold}${integration}${C.reset})`);
+  for (const name of activeNames) {
     const bin = findBinary(name);
     if (bin) {
       ok(`${name}  ${C.dim}${bin}${C.reset}`);
@@ -99,6 +119,18 @@ module.exports = async function verify(opts) {
     warn(`Set AZURE_CLIENT_ID + AZURE_CLIENT_SECRET + AZURE_TENANT_ID for CI/CD.`);
   }
 
+  // ── 3b. Jira auth cache ──────────────────────────────────────────────────────
+  head("Jira Auth (OAuth 2.0)");
+  const jiraCache = path.join(os.homedir(), ".jira-cache", "jira-token.json");
+  if (fs.existsSync(jiraCache)) {
+    const stat = fs.statSync(jiraCache);
+    ok(`Token cache found  ${C.dim}${jiraCache}  (${Math.round(stat.size / 1024)} KB)${C.reset}`);
+  } else {
+    warn(`No Jira token cache at ${jiraCache}`);
+    warn(`A browser will open the first time qa-jira-manager is called.`);
+    warn(`Set JIRA_CLIENT_ID + JIRA_CLIENT_SECRET + JIRA_CLOUD_ID in .env`);
+  }
+
   // ── 4. MCP config files ───────────────────────────────────────────────────
   head("MCP Config");
   const mcpJson   = path.join(CWD, ".mcp.json");
@@ -126,4 +158,4 @@ module.exports = async function verify(opts) {
   }
 
   console.log();
-};
+};

package/src/cli/prompt-integration.js

@@ -0,0 +1,87 @@
+/**
+ * prompt-integration.js — Interactive integration picker
+ *
+ * Presents a numbered menu asking the user which integration(s) they want:
+ *   1. Azure DevOps only  (Agents 1–4)
+ *   2. Jira Cloud only    (Full pipeline: qa-jira-manager + shared Agents 2–4)
+ *   3. Both
+ *
+ * Works in interactive terminals (TTY). Falls back to a default (ado) when
+ * stdin is not a TTY (e.g. CI, piped installs) — callers can override the
+ * default via the `fallback` argument.
+ *
+ * Returns a Promise that resolves to: "ado" | "jira" | "both"
+ *
+ * Usage:
+ *   const pickIntegration = require("./prompt-integration");
+ *   const integration = await pickIntegration();  // "ado" | "jira" | "both"
+ */
+"use strict";
+
+const readline = require("readline");
+
+const C = {
+  reset: "\x1b[0m", bold: "\x1b[1m",
+  green: "\x1b[32m", cyan: "\x1b[36m",
+  yellow: "\x1b[33m", dim: "\x1b[2m", blue: "\x1b[34m",
+};
+
+const MENU = `
+${C.bold}Which project management integration do you need?${C.reset}
+
+  ${C.cyan}1${C.reset}  ${C.bold}Azure DevOps${C.reset}   ${C.dim}(Agents 1–4: test cases, Gherkin, Playwright, Helix-QA)${C.reset}
+  ${C.cyan}2${C.reset}  ${C.bold}Jira Cloud${C.reset}     ${C.dim}(Full pipeline: fetch issues → test cases → Gherkin → Playwright → Helix-QA)${C.reset}
+  ${C.cyan}3${C.reset}  ${C.bold}Both${C.reset}           ${C.dim}(All five agents — use ADO and Jira side by side)${C.reset}
+
+  ${C.dim}Tip: you can change this later with  qa-stlc init --integration <ado|jira|both>${C.reset}
+
+Enter 1, 2, or 3 [default: 1]: `;
+
+const CHOICES = { "1": "ado", "2": "jira", "3": "both", "": "ado" };
+
+/**
+ * @param {string} [fallback="ado"] - Value to return when stdin is not a TTY.
+ * @returns {Promise<"ado"|"jira"|"both">}
+ */
+module.exports = function pickIntegration(fallback = "ado") {
+  // Non-interactive environment — skip the prompt entirely
+  if (!process.stdin.isTTY) {
+    console.log(
+      `${C.dim}→  Non-interactive install — defaulting to integration: ${C.reset}${C.bold}${fallback}${C.reset}`
+    );
+    console.log(
+      `${C.dim}   To change, run:  qa-stlc init --integration <ado|jira|both>${C.reset}\n`
+    );
+    return Promise.resolve(fallback);
+  }
+
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input:  process.stdin,
+      output: process.stdout,
+    });
+
+    function ask() {
+      rl.question(MENU, (answer) => {
+        const trimmed = answer.trim();
+        const choice  = CHOICES[trimmed];
+
+        if (choice) {
+          rl.close();
+          const label = choice === "ado"  ? "Azure DevOps"
+                      : choice === "jira" ? "Jira Cloud"
+                      :                     "Azure DevOps + Jira Cloud";
+          console.log(`\n${C.green}✓${C.reset}  Integration selected: ${C.bold}${label}${C.reset}\n`);
+          resolve(choice);
+        } else {
+          console.log(
+            `${C.yellow}  Please enter 1, 2, or 3.${C.reset}`
+          );
+          ask();
+        }
+      });
+    }
+
+    ask();
+  });
+};