jiradc-cli 1.0.28 → 1.0.30

package/dist/index.js

@@ -53,6 +53,18 @@ function listOf(item) {
 function text(raw) {
   return raw;
 }
+function nonEmpty(raw) {
+  if (raw.trim() === "") {
+    throw new InvalidArgumentError("Must not be empty.");
+  }
+  return raw;
+}
+function integer(raw) {
+  if (!/^[+-]?\d+$/.test(raw.trim())) {
+    throw new InvalidArgumentError("Must be an integer.");
+  }
+  return Number(raw);
+}
 function date(raw) {
   const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw);
   if (!m) {
@@ -412,7 +424,7 @@ async function runCli(program, opts) {
 
 // src/program.ts
 import { styleText } from "util";
-import { Command as Command11 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/commands/board/issues.ts
 import { Argument } from "commander";
@@ -762,6 +774,134 @@ function transformTransitions(response) {
   return response.transitions.map(transformTransition);
 }
 
+// src/utils/transformers/xray.ts
+function extractStepFields(s) {
+  const out = {};
+  const raw = s.fields?.Action?.value?.raw;
+  if (raw !== void 0) out.action = raw;
+  const data = s.fields?.Data?.value?.raw;
+  if (data !== void 0) out.data = data;
+  const result = s.fields?.["Expected Result"]?.value?.raw;
+  if (result !== void 0) out.result = result;
+  return out;
+}
+function extractDefinitionStep(s) {
+  const out = {};
+  if (s.id !== void 0) out.id = s.id;
+  if (s.index !== void 0) out.index = s.index;
+  if (s.step?.raw !== void 0) out.action = s.step.raw;
+  if (s.data?.raw !== void 0) out.data = s.data.raw;
+  if (s.result?.raw !== void 0) out.result = s.result.raw;
+  return out;
+}
+function transformStep(s) {
+  return {
+    ...s.id !== void 0 && { id: s.id },
+    ...s.index !== void 0 && { index: s.index },
+    ...extractStepFields(s)
+  };
+}
+function transformTest(test) {
+  const out = {};
+  if (test.key !== void 0) out.key = test.key;
+  if (test.type !== void 0) out.type = test.type;
+  if (test.status !== void 0) out.status = test.status;
+  const rawSteps = test.definition?.steps;
+  if (Array.isArray(rawSteps) && rawSteps.length > 0) {
+    out.steps = rawSteps.map((s) => extractDefinitionStep(s));
+  }
+  return out;
+}
+function transformTestList(result) {
+  const tests = Array.isArray(result) ? result : result.tests ?? [];
+  return tests.map((t) => ({
+    ...t.key !== void 0 && { key: String(t.key) },
+    ...t.summary !== void 0 && { summary: String(t.summary) },
+    ...typeof t.status === "string" && { status: t.status },
+    ...typeof t.type === "string" && { type: t.type }
+  }));
+}
+function transformLink(link2) {
+  const out = {};
+  if (link2.key !== void 0) out.key = String(link2.key);
+  if (link2.summary !== void 0) out.summary = String(link2.summary);
+  if (typeof link2.status === "string") out.status = link2.status;
+  return out;
+}
+function transformLinks(links) {
+  return links.map(transformLink);
+}
+function transformStatuses(statuses) {
+  return statuses.map((s) => ({
+    ...s.name !== void 0 && { name: s.name },
+    ...s.description !== void 0 && { description: s.description },
+    ...s.final !== void 0 && { final: s.final },
+    ...s.color !== void 0 && { color: s.color },
+    ...s.requirementStatusName !== void 0 && { requirementStatusName: s.requirementStatusName }
+  }));
+}
+var XRAY_CUSTOM_MARKER = "xpandit";
+function isXrayField(f) {
+  return f.schema?.custom?.includes(XRAY_CUSTOM_MARKER) === true;
+}
+function transformFields(fields) {
+  return fields.filter(isXrayField).map((f) => ({
+    id: f.id,
+    name: f.name,
+    ...f.schema?.type !== void 0 && { type: f.schema.type }
+  }));
+}
+function transformEvidence(evidence) {
+  return evidence.map((e) => ({
+    ...e.id !== void 0 && { id: e.id },
+    ...e.fileName !== void 0 && { fileName: e.fileName },
+    ...e.fileSize !== void 0 && { fileSize: e.fileSize },
+    ...e.contentType !== void 0 && { contentType: e.contentType },
+    ...e.created !== void 0 && { created: e.created }
+  }));
+}
+function transformRunSteps(steps) {
+  return steps.map((s) => ({
+    ...s.id !== void 0 && { id: s.id },
+    ...s.status !== void 0 && { status: s.status },
+    ...s.comment !== void 0 && { comment: s.comment },
+    ...s.actualResult !== void 0 && { actualResult: s.actualResult }
+  }));
+}
+function transformRun(run) {
+  const out = {};
+  if (run.id !== void 0) out.id = run.id;
+  if (run.status !== void 0) out.status = run.status;
+  if (run["testKey"] !== void 0) out.testKey = run["testKey"];
+  if (run["testExecKey"] !== void 0) out.testExecKey = run["testExecKey"];
+  if (run.assignee !== void 0) out.assignee = run.assignee;
+  if (run.executedBy !== void 0) out.executedBy = run.executedBy;
+  if (run.comment !== void 0) out.comment = run.comment;
+  if (run["defects"] !== void 0) out.defects = run["defects"];
+  if (Array.isArray(run["steps"])) {
+    out.steps = run["steps"].map((s) => ({
+      ...s.id !== void 0 && { id: s.id },
+      ...s.index !== void 0 && { index: s.index },
+      ...extractStepFields(s)
+    }));
+  }
+  return out;
+}
+function transformFolderNode(folder) {
+  const out = {};
+  if (folder.id !== void 0) out.id = folder.id;
+  if (folder.name !== void 0) out.name = folder.name;
+  if (folder.testRepositoryPath !== void 0) out.path = folder.testRepositoryPath;
+  if (folder.testCount !== void 0) out.testCount = folder.testCount;
+  if (Array.isArray(folder.folders) && folder.folders.length > 0) {
+    out.folders = folder.folders.map(transformFolderNode);
+  }
+  return out;
+}
+function transformFolderTree(root) {
+  return transformFolderNode(root);
+}
+
 // src/commands/board/issues.ts
 function issues(parent) {
   const cmd = parent.command("issues").description("Get issues for a board").addArgument(new Argument("<id>", "Board ID").argParser(positiveInt)).option("--limit <number>", "Max results (1-50, Jira DC caps at 50)", intInRange(1, 50), 25).option("--start <number>", "Starting index for pagination", nonNegativeInt).option("--fields <fields>", "Comma-separated field names to return", text).option("--jql <jql>", "Additional JQL filter within the board", text);
@@ -992,6 +1132,7 @@ async function resolveUserToken(token) {
 }
 
 // src/utils/validators.ts
+import { existsSync } from "fs";
 import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
 function issueKey(raw) {
   if (!/^(\d+|[A-Z][A-Z0-9]+-\d+)$/.test(raw)) {
@@ -999,6 +1140,16 @@ function issueKey(raw) {
   }
   return raw;
 }
+function keyList(raw) {
+  const keys = raw.split(",").map((k) => k.trim()).filter(Boolean);
+  if (keys.length === 0) throw new InvalidArgumentError4("Provide at least one comma-separated issue key.");
+  for (const k of keys) issueKey(k);
+  return keys;
+}
+function filePath(raw) {
+  if (!existsSync(raw)) throw new InvalidArgumentError4(`File not found: ${raw}`);
+  return raw;
+}
 
 // src/commands/issue/assign.ts
 function assign(parent) {
@@ -1130,8 +1281,8 @@ function upload(parent) {
     const client = getClient();
     const filePaths = opts.files.split(",").map((f) => f.trim());
     const results = [];
-    for (const filePath of filePaths) {
-      const attachments = await client.issues.addAttachment({ issueKeyOrId: key, filePath });
+    for (const filePath2 of filePaths) {
+      const attachments = await client.issues.addAttachment({ issueKeyOrId: key, filePath: filePath2 });
       results.push(...attachments);
     }
     output({
@@ -1171,9 +1322,9 @@ function batchChangelog(parent) {
   examples(cmd, ["PROJ-1,PROJ-2,PROJ-3", "PROJ-123,PROJ-124 --limit 10"]);
   cmd.action(async (keys, opts) => {
     const client = getClient();
-    const keyList = keys.split(",").map((k) => k.trim());
+    const keyList2 = keys.split(",").map((k) => k.trim());
     const entries = await Promise.all(
-      keyList.map(async (key) => {
+      keyList2.map(async (key) => {
         try {
           const data = await client.issues.getChangelog({ issueKeyOrId: key, maxResults: opts.limit });
           return [key, data];
@@ -1799,8 +1950,8 @@ function update3(parent) {
     const uploaded = [];
     if (opts.attachments) {
       const filePaths = opts.attachments.split(",").map((p) => p.trim()).filter(Boolean);
-      for (const filePath of filePaths) {
-        const result = await client.issues.addAttachment({ issueKeyOrId: key, filePath });
+      for (const filePath2 of filePaths) {
+        const result = await client.issues.addAttachment({ issueKeyOrId: key, filePath: filePath2 });
         for (const att of result) {
           uploaded.push({ filename: att.filename, id: att.id });
         }
@@ -2246,11 +2397,1517 @@ function registerUserCommands(program) {
   search3(user);
 }
 
+// src/utils/xray/guards.ts
+function assertExactlyOne(opts, keys, label) {
+  const present = keys.filter((k) => opts[k] !== void 0);
+  if (present.length !== 1)
+    throw new Error(`Provide exactly one of ${keys.map((k) => `--${k}`).join(", ")} (${label}).`);
+  return present[0];
+}
+function assertAtLeastOne(opts, keys) {
+  if (!keys.some((k) => opts[k] !== void 0))
+    throw new Error(`Provide at least one of ${keys.map((k) => `--${k}`).join(", ")}.`);
+}
+
+// src/commands/xray/execution/add.ts
+function add(parent) {
+  const cmd = parent.command("add").description("Add tests to a Test Execution, directly (--test) and/or by expanding Test Sets (--set)").argument("<execKey>", "Test Execution issue key (e.g. AI-200)", issueKey).option("--test <keys>", "Comma-separated test issue keys to add (e.g. AI-1,AI-2)", keyList).option(
+    "--set <keys>",
+    "Comma-separated Test Set keys; each set's current tests are added to the execution (e.g. AI-300)",
+    keyList
+  );
+  examples(cmd, [
+    "AI-200 --test AI-1",
+    "AI-200 --test AI-1,AI-2",
+    "AI-200 --set AI-300",
+    "AI-200 --test AI-1 --set AI-300"
+  ]);
+  cmd.action(async (execKey, opts) => {
+    assertAtLeastOne(opts, ["test", "set"]);
+    const client = getClient();
+    const keys = new Set(opts.test ?? []);
+    if (opts.set) {
+      const lists = await Promise.all(opts.set.map((setKey) => client.testSets.listTests({ setKey })));
+      for (const list20 of lists) {
+        const tests = Array.isArray(list20) ? list20 : list20.tests ?? [];
+        for (const t of tests) {
+          if (t.key) keys.add(String(t.key));
+        }
+      }
+    }
+    const allKeys = [...keys];
+    if (allKeys.length === 0) {
+      throw new Error("No tests to add \u2014 the given --set(s) contain no tests and no --test keys were provided.");
+    }
+    const result = await client.testExecutions.addTests({ execKey, keys: allKeys });
+    output(result ?? { added: allKeys });
+  });
+}
+
+// src/utils/xray/issue-entity.ts
+var XRAY_ISSUE_TYPES = {
+  Test: "Test",
+  TestSet: "Test Set",
+  TestPlan: "Test Plan",
+  TestExecution: "Test Execution",
+  PreCondition: "Pre-Condition"
+};
+function createXrayIssue(client, params) {
+  return client.issues.create({
+    projectKeyOrId: params.project,
+    issueTypeName: params.type,
+    summary: params.summary,
+    description: params.description,
+    customFields: params.customFields
+  });
+}
+function updateXrayIssue(client, key, params) {
+  const fields = {};
+  if (params.summary !== void 0) fields.summary = params.summary;
+  if (params.description !== void 0) fields.description = params.description;
+  if (params.customFields !== void 0) Object.assign(fields, params.customFields);
+  return client.issues.update({ issueKeyOrId: key, fields });
+}
+function deleteXrayIssue(client, key) {
+  return client.issues.delete({ issueKeyOrId: key });
+}
+
+// src/commands/xray/execution/create.ts
+function create7(parent) {
+  const cmd = parent.command("create").description("Create a new Xray Test Execution issue").requiredOption("--project <key>", "Project key (e.g. AI)", text).requiredOption("--summary <text>", "Test Execution summary (title)", text);
+  textOrFileOption(cmd, "description", { description: "Test Execution description" });
+  examples(cmd, [
+    '--project AI --summary "Sprint 42 regression run"',
+    '--project AI --summary "Smoke run" --description "Post-deploy smoke"'
+  ]);
+  cmd.action(async (opts) => {
+    const description = resolveTextOrFile(opts, "description", { required: false });
+    const client = getClient();
+    const result = await createXrayIssue(client, {
+      project: opts.project,
+      type: XRAY_ISSUE_TYPES.TestExecution,
+      summary: opts.summary,
+      description
+    });
+    output(transformCreatedIssue(result));
+  });
+}
+
+// src/commands/xray/execution/delete.ts
+function deleteExecution(parent) {
+  const cmd = parent.command("delete").description("Delete an Xray Test Execution issue").argument("<execKey>", "Test Execution issue key (e.g. AI-200)", issueKey);
+  examples(cmd, ["AI-200"]);
+  cmd.action(async (execKey) => {
+    const client = getClient();
+    await deleteXrayIssue(client, execKey);
+    output({ deleted: true, key: execKey });
+  });
+}
+
+// src/commands/xray/execution/list.ts
+function list8(parent) {
+  const cmd = parent.command("list").description(
+    "List Test Executions that contain a given test (inverse view). For the tests inside an execution, use: xray test list --execution <key>."
+  ).requiredOption("--test <key>", "Test issue key whose executions to list (e.g. AI-584)", issueKey);
+  examples(cmd, ["--test AI-584"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const executions = await client.xrayTests.getTestExecutions({ testKey: opts.test });
+    output(transformLinks(executions));
+  });
+}
+
+// src/commands/xray/execution/remove.ts
+function remove(parent) {
+  const cmd = parent.command("remove").description("Remove tests from a Test Execution").argument("<execKey>", "Test Execution issue key (e.g. AI-200)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. AI-1,AI-2)", keyList);
+  examples(cmd, ["AI-200 --test AI-1", "AI-200 --test AI-1,AI-2"]);
+  cmd.action(async (execKey, opts) => {
+    const client = getClient();
+    const result = await client.testExecutions.removeTests({ execKey, keys: opts.test });
+    output(result ?? { removed: true });
+  });
+}
+
+// src/commands/xray/execution/update.ts
+function update6(parent) {
+  const cmd = parent.command("update").description("Update an Xray Test Execution issue").argument("<execKey>", "Test Execution issue key (e.g. AI-200)", issueKey).option("--summary <text>", "New summary (title)", text);
+  textOrFileOption(cmd, "description", { description: "New Test Execution description" });
+  examples(cmd, ['AI-200 --summary "Updated execution title"', 'AI-200 --description "Post-hotfix run"']);
+  cmd.action(async (execKey, opts) => {
+    const description = resolveTextOrFile(opts, "description", { required: false });
+    const client = getClient();
+    await updateXrayIssue(client, execKey, { summary: opts.summary, description });
+    output({ key: execKey });
+  });
+}
+
+// src/commands/xray/execution/index.ts
+function registerExecutionCommands(xray) {
+  const execution2 = xray.command("execution").description(
+    "Xray Test Execution issue management (CRUD, membership). To list tests inside an execution, use: xray test list --execution <key>."
+  );
+  examples(execution2, [
+    'create --project AI --summary "Sprint 42 regression run"',
+    "add AI-200 --test AI-1,AI-2",
+    "list --test AI-584"
+  ]);
+  create7(execution2);
+  update6(execution2);
+  deleteExecution(execution2);
+  add(execution2);
+  remove(execution2);
+  list8(execution2);
+}
+
+// src/commands/xray/export/feature.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join5 } from "path";
+function feature(parent) {
+  const cmd = parent.command("feature").description("Export Gherkin .feature files for the given test keys").requiredOption("--test <keys>", "Comma-separated Test, Set, Plan, or Execution issue keys", keyList).option("--output <path>", "Write the exported file to this path (default: ./<filename> from response)", text).option("--zip", "Request a zip archive instead of a single .feature file");
+  examples(cmd, ["--test AI-584 --output ai-584.feature"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const { data, filename } = await client.xrayExport.exportFeature({
+      keys: opts.test,
+      zip: opts.zip
+    });
+    const writePath = opts.output ?? join5(".", basename(filename));
+    writeFileSync2(writePath, data);
+    output({ written: writePath, bytes: data.length });
+  });
+}
+
+// src/commands/xray/export/index.ts
+function registerExportCommands(xray) {
+  const exportGroup = xray.command("export").description("Export Xray test artifacts (feature files)");
+  feature(exportGroup);
+}
+
+// src/commands/xray/field/list.ts
+function list9(parent) {
+  const cmd = parent.command("list").description("List Xray custom fields available on this instance");
+  examples(cmd, [""]);
+  cmd.action(async () => {
+    const client = getClient();
+    output(transformFields(await client.fields.getAll()));
+  });
+}
+
+// src/commands/xray/field/index.ts
+function registerFieldCommands2(xray) {
+  const field = xray.command("field").description("Xray field discovery");
+  examples(field, ["list"]);
+  list9(field);
+}
+
+// src/commands/xray/folder/add.ts
+function add2(parent) {
+  const cmd = parent.command("add").description("Add tests to a folder in the test repository").argument("<folderId>", "Folder id (from folder list)", positiveInt).requiredOption("--project <key>", "Project key (e.g. QA)", text).requiredOption("--test <keys>", "Comma-separated test issue keys to add (e.g. QA-1,QA-2)", keyList);
+  examples(cmd, ["818 --project QA --test QA-1", "818 --project QA --test QA-1,QA-2,QA-3"]);
+  cmd.action(async (folderId, opts) => {
+    const client = getClient();
+    const result = await client.testRepository.updateFolderTests({
+      projectKey: opts.project,
+      folderId,
+      add: opts.test
+    });
+    output(result ?? { added: true });
+  });
+}
+
+// src/commands/xray/folder/create.ts
+function create8(parent) {
+  const cmd = parent.command("create").description("Create a new folder in the test repository").requiredOption("--project <key>", "Project key (e.g. QA)", text).option("--parent-id <id>", "Parent folder id (-1 = root)", integer, -1).requiredOption("--name <text>", "Folder name", text);
+  examples(cmd, [
+    "--project QA --name Smoke",
+    '--project QA --parent-id -1 --name "Regression Suite"',
+    '--project AI --parent-id 818 --name "Sub-folder"'
+  ]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const result = await client.testRepository.createFolder({
+      projectKey: opts.project,
+      parentId: opts.parentId,
+      name: opts.name
+    });
+    output(result);
+  });
+}
+
+// src/commands/xray/folder/delete.ts
+function deleteFolder(parent) {
+  const cmd = parent.command("delete").description("Delete a folder from the test repository").argument("<folderId>", "Folder id to delete (from folder list)", positiveInt).requiredOption("--project <key>", "Project key (e.g. QA)", text);
+  examples(cmd, ["818 --project QA", "42 --project AI"]);
+  cmd.action(async (folderId, opts) => {
+    const client = getClient();
+    await client.testRepository.deleteFolder({ projectKey: opts.project, folderId });
+    output({ folderId, deleted: true });
+  });
+}
+
+// src/commands/xray/folder/list.ts
+function list10(parent) {
+  const cmd = parent.command("list").description("List the test repository folder tree for a project").requiredOption("--project <key>", "Project key (e.g. QA)", text);
+  examples(cmd, ["--project QA", "--project AI"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const tree = await client.testRepository.getFolders({ projectKey: opts.project });
+    output(transformFolderTree(tree));
+  });
+}
+
+// src/commands/xray/folder/remove.ts
+function remove2(parent) {
+  const cmd = parent.command("remove").description("Remove tests from a folder in the test repository").argument("<folderId>", "Folder id (from folder list)", positiveInt).requiredOption("--project <key>", "Project key (e.g. QA)", text).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. QA-1,QA-2)", keyList);
+  examples(cmd, ["818 --project QA --test QA-1", "818 --project QA --test QA-1,QA-2"]);
+  cmd.action(async (folderId, opts) => {
+    const client = getClient();
+    const result = await client.testRepository.updateFolderTests({
+      projectKey: opts.project,
+      folderId,
+      remove: opts.test
+    });
+    output(result ?? { removed: true });
+  });
+}
+
+// src/commands/xray/folder/update.ts
+function update7(parent) {
+  const cmd = parent.command("update").description("Rename or reorder a folder in the test repository").argument("<folderId>", "Folder id (from folder list)", positiveInt).requiredOption("--project <key>", "Project key (e.g. QA)", text).option("--name <text>", "New folder name", text).option("--rank <id>", "New folder rank/position", positiveInt);
+  examples(cmd, [
+    '818 --project QA --name "New Name"',
+    "818 --project QA --rank 2",
+    "818 --project AI --name Smoke --rank 1"
+  ]);
+  cmd.action(async (folderId, opts) => {
+    if (opts.name === void 0 && opts.rank === void 0) {
+      throw new Error("Provide at least one of --name or --rank.");
+    }
+    const client = getClient();
+    await client.testRepository.updateFolder({
+      projectKey: opts.project,
+      folderId,
+      name: opts.name,
+      rank: opts.rank
+    });
+    output({ folderId, updated: true });
+  });
+}
+
+// src/commands/xray/folder/index.ts
+function registerFolderCommands(xray) {
+  const folder = xray.command("folder").description(
+    "Xray Test Repository folder management (rename/reorder within parent only \u2014 cross-parent moves are UI-only, not supported by the API). To list tests in a folder use: xray test list --folder <id> --project <key>"
+  );
+  examples(folder, ["list --project QA", "create --project QA --parent-id -1 --name Smoke"]);
+  list10(folder);
+  create8(folder);
+  update7(folder);
+  deleteFolder(folder);
+  add2(folder);
+  remove2(folder);
+}
+
+// src/commands/xray/import/execution.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename as basename2 } from "path";
+import { Option as Option9 } from "commander";
+var FORMATS = ["xray", "junit", "testng", "nunit", "xunit", "robot", "cucumber", "behave"];
+var NEEDS_SCOPE = /* @__PURE__ */ new Set(["junit", "testng", "nunit", "xunit", "robot"]);
+function execution(parent) {
+  const cmd = parent.command("execution").description("Import test execution results into Xray").requiredOption("--file <path>", "Path to the result file", filePath).addOption(
+    new Option9(
+      "--format <format>",
+      "Result format. xray/cucumber/behave: JSON body, no --project/--execution required. junit/testng/nunit/xunit/robot: XML body, requires --project OR --execution."
+    ).choices(FORMATS).makeOptionMandatory()
+  ).option(
+    "--project <text>",
+    "Project key \u2014 required for junit/testng/nunit/xunit/robot when --execution is not provided",
+    text
+  ).option(
+    "--execution <key>",
+    "Import into an existing Test Execution \u2014 required for junit/testng/nunit/xunit/robot when --project is not provided",
+    issueKey
+  ).option("--plan <key>", "Associate with a Test Plan issue key", issueKey).option("--fix-version <text>", "Fix version to set on the Test Execution", text).option("--revision <text>", "Source control revision", text).option("--environments <text>", "Comma-separated test environment names", text);
+  examples(cmd, [
+    "--file results.xml --format junit --project AI",
+    "--file results.xml --format junit --execution AI-100",
+    "--file results.json --format xray"
+  ]);
+  cmd.action(
+    async (opts) => {
+      if (NEEDS_SCOPE.has(opts.format) && !opts.project && !opts.execution) {
+        throw new Error(
+          `--project or --execution is required for ${opts.format} format. Provide --project <key> to create a new execution, or --execution <key> to import into an existing one.`
+        );
+      }
+      const body = readFileSync4(opts.file);
+      const query = {};
+      if (opts.project) query["projectKey"] = opts.project;
+      if (opts.execution) query["testExecKey"] = opts.execution;
+      if (opts.plan) query["testPlanKey"] = opts.plan;
+      if (opts.fixVersion) query["fixVersion"] = opts.fixVersion;
+      if (opts.revision) query["revision"] = opts.revision;
+      if (opts.environments) query["testEnvironments"] = opts.environments;
+      const client = getClient();
+      const result = await client.xrayImport.importExecution({
+        format: opts.format,
+        body,
+        filename: basename2(opts.file),
+        query: Object.keys(query).length > 0 ? query : void 0
+      });
+      output(result);
+    }
+  );
+}
+
+// src/commands/xray/import/feature.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { basename as basename3 } from "path";
+function feature2(parent) {
+  const cmd = parent.command("feature").description("Import a Gherkin .feature file into the Xray test repository (multipart)").requiredOption("--file <path>", "Path to the .feature file", filePath).requiredOption("--project <text>", "Project key to import the feature into", text);
+  examples(cmd, ["--file login.feature --project AI"]);
+  cmd.action(async (opts) => {
+    const fileBuffer = readFileSync5(opts.file);
+    const filename = basename3(opts.file);
+    const client = getClient();
+    const result = await client.xrayImport.importFeature({
+      projectKey: opts.project,
+      file: fileBuffer,
+      filename
+    });
+    output(result);
+  });
+}
+
+// src/commands/xray/import/index.ts
+function registerImportCommands(xray) {
+  const importGroup = xray.command("import").description("Import test results and feature files into Xray");
+  execution(importGroup);
+  feature2(importGroup);
+}
+
+// src/commands/xray/plan/add.ts
+function add3(parent) {
+  const cmd = parent.command("add").description("Add tests and/or executions to a Test Plan").argument("<planKey>", "Test Plan issue key (e.g. QA-573)", issueKey).option("--test <keys>", "Comma-separated test issue keys to add (e.g. QA-1,QA-2)", keyList).option("--execution <keys>", "Comma-separated test execution keys to add (e.g. QA-200,QA-201)", keyList);
+  examples(cmd, ["QA-573 --test QA-1,QA-2", "QA-573 --execution QA-200", "QA-573 --test QA-1 --execution QA-200"]);
+  cmd.action(async (planKey, opts) => {
+    assertAtLeastOne(opts, ["test", "execution"]);
+    const client = getClient();
+    const promises = [];
+    if (opts.test) promises.push(client.testPlans.addTests({ planKey, keys: opts.test }));
+    if (opts.execution) promises.push(client.testPlans.addExecutions({ planKey, keys: opts.execution }));
+    const out = await Promise.all(promises);
+    output(out);
+  });
+}
+
+// src/commands/xray/plan/create.ts
+function create9(parent) {
+  const cmd = parent.command("create").description("Create a new Xray Test Plan issue").requiredOption("--project <key>", "Project key (e.g. QA)", text).requiredOption("--summary <text>", "Test Plan summary (title)", text);
+  textOrFileOption(cmd, "description", { description: "Test Plan description" });
+  examples(cmd, [
+    '--project QA --summary "Q3 regression plan"',
+    '--project QA --summary "Sprint 42 plan" --description "Covers all sprint stories"'
+  ]);
+  cmd.action(async (opts) => {
+    const description = resolveTextOrFile(opts, "description", { required: false });
+    const client = getClient();
+    const result = await createXrayIssue(client, {
+      project: opts.project,
+      type: XRAY_ISSUE_TYPES.TestPlan,
+      summary: opts.summary,
+      description
+    });
+    output(transformCreatedIssue(result));
+  });
+}
+
+// src/commands/xray/plan/delete.ts
+function deletePlan(parent) {
+  const cmd = parent.command("delete").description("Delete an Xray Test Plan issue").argument("<planKey>", "Test Plan issue key (e.g. QA-573)", issueKey);
+  examples(cmd, ["QA-573"]);
+  cmd.action(async (planKey) => {
+    const client = getClient();
+    await deleteXrayIssue(client, planKey);
+    output({ deleted: true, key: planKey });
+  });
+}
+
+// src/commands/xray/plan/list.ts
+function list11(parent) {
+  const cmd = parent.command("list").description(
+    "List Test Plans that contain a given test (inverse view). For the tests inside a plan, use: xray test list --plan <key>. For executions in a plan, use: xray execution list --plan <key>."
+  ).requiredOption("--test <key>", "Test issue key whose plans to list (e.g. QA-574)", issueKey);
+  examples(cmd, ["--test QA-574"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const plans = await client.xrayTests.getTestPlans({ testKey: opts.test });
+    output(transformLinks(plans));
+  });
+}
+
+// src/commands/xray/plan/remove.ts
+function remove3(parent) {
+  const cmd = parent.command("remove").description("Remove tests and/or executions from a Test Plan").argument("<planKey>", "Test Plan issue key (e.g. QA-573)", issueKey).option("--test <keys>", "Comma-separated test issue keys to remove (e.g. QA-1,QA-2)", keyList).option("--execution <keys>", "Comma-separated test execution keys to remove (e.g. QA-200)", keyList);
+  examples(cmd, ["QA-573 --test QA-1", "QA-573 --execution QA-200", "QA-573 --test QA-1 --execution QA-200"]);
+  cmd.action(async (planKey, opts) => {
+    assertAtLeastOne(opts, ["test", "execution"]);
+    const client = getClient();
+    const promises = [];
+    if (opts.test) promises.push(client.testPlans.removeTests({ planKey, keys: opts.test }));
+    if (opts.execution) promises.push(client.testPlans.removeExecutions({ planKey, keys: opts.execution }));
+    const out = await Promise.all(promises);
+    output(out);
+  });
+}
+
+// src/commands/xray/plan/update.ts
+function update8(parent) {
+  const cmd = parent.command("update").description("Update an Xray Test Plan issue").argument("<planKey>", "Test Plan issue key (e.g. QA-573)", issueKey).option("--summary <text>", "New summary (title)", text);
+  textOrFileOption(cmd, "description", { description: "New Test Plan description" });
+  examples(cmd, ['QA-573 --summary "Updated plan title"', 'QA-573 --description "Revised scope"']);
+  cmd.action(async (planKey, opts) => {
+    const description = resolveTextOrFile(opts, "description", { required: false });
+    const client = getClient();
+    await updateXrayIssue(client, planKey, { summary: opts.summary, description });
+    output({ key: planKey });
+  });
+}
+
+// src/commands/xray/plan/index.ts
+function registerPlanCommands(xray) {
+  const plan = xray.command("plan").description(
+    "Xray Test Plan issue management (CRUD, membership). To list tests inside a plan, use: xray test list --plan <key>."
+  );
+  examples(plan, [
+    'create --project QA --summary "Q3 regression plan"',
+    "add QA-573 --test QA-1,QA-2",
+    "add QA-573 --test QA-1 --execution QA-200",
+    "list --test QA-574"
+  ]);
+  create9(plan);
+  update8(plan);
+  deletePlan(plan);
+  add3(plan);
+  remove3(plan);
+  list11(plan);
+}
+
+// src/commands/xray/precondition/add.ts
+function add4(parent) {
+  const cmd = parent.command("add").description("Add tests to a Pre-Condition").argument("<preKey>", "Pre-Condition issue key (e.g. BD-50)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to add (e.g. AI-1,AI-2)", keyList);
+  examples(cmd, ["BD-50 --test AI-1", "BD-50 --test AI-1,AI-2,AI-3"]);
+  cmd.action(async (preKey, opts) => {
+    const client = getClient();
+    const result = await client.preconditions.addTests({ preKey, keys: opts.test });
+    output(result ?? { added: true });
+  });
+}
+
+// src/commands/xray/precondition/create.ts
+import { Option as Option10 } from "commander";
+
+// src/utils/xray/fields.ts
+var CONCEPT_SUFFIX = {
+  "test-type": "test-type-custom-field",
+  "manual-steps": "manual-test-steps-custom-field",
+  "cucumber-test-type": "automated-test-type-custom-field",
+  "cucumber-scenario": "steps-editor-custom-field",
+  "generic-definition": "path-editor-custom-field",
+  "test-repository-path": "test-repository-path-custom-field",
+  "precondition-type": "precondition-test-type-custom-field",
+  "precondition-body": "precondition-editor-custom-field"
+};
+async function resolveXrayFields(client) {
+  const fields = await client.fields.getAll();
+  const map = {};
+  for (const [concept, suffix] of Object.entries(CONCEPT_SUFFIX)) {
+    const field = fields.find((f) => {
+      const custom = f.schema?.custom;
+      return typeof custom === "string" && custom.endsWith(`:${suffix}`);
+    });
+    if (field) {
+      map[concept] = field.id;
+    }
+  }
+  return map;
+}
+function resolveTestTypeValue(allowedValues, type) {
+  if (type === "manual") {
+    const match2 = allowedValues.find((v) => /manual/i.test(v));
+    if (!match2)
+      throw new Error(`No 'manual' Test Type value found on this instance. Available: ${allowedValues.join(", ")}`);
+    return match2;
+  }
+  if (type === "generic") {
+    const match2 = allowedValues.find((v) => /generic/i.test(v));
+    if (!match2)
+      throw new Error(`No 'generic' Test Type value found on this instance. Available: ${allowedValues.join(", ")}`);
+    return match2;
+  }
+  const match = allowedValues.find((v) => !/manual/i.test(v) && !/generic/i.test(v));
+  if (!match)
+    throw new Error(
+      `No 'cucumber' (gherkin/automation) Test Type value found on this instance. Available: ${allowedValues.join(", ")}`
+    );
+  return match;
+}
+async function resolveTypeValue(client, params) {
+  const meta = await client.issues.getCreateMeta({
+    projectKey: params.projectKey,
+    issueTypeName: params.issueTypeName
+  });
+  const fieldId = params.fieldMap[params.fieldConceptKey];
+  const issuetype = meta.projects?.[0]?.issuetypes?.[0];
+  const fieldMeta = fieldId ? issuetype?.fields?.[fieldId] : void 0;
+  const allowedValues = (fieldMeta?.allowedValues ?? []).map((av) => av.value ?? "").filter(Boolean);
+  if (allowedValues.length > 0) {
+    return resolveTestTypeValue(allowedValues, params.type);
+  }
+  return params.type === "manual" ? "Manual" : params.type === "generic" ? "Generic" : "Cucumber";
+}
+function requireField(map, concept, label) {
+  const id = map[concept];
+  if (!id) throw new Error(`Xray field for '${label}' not found on this instance.`);
+  return id;
+}
+function buildTestCustomFields(map, opts) {
+  const fields = {};
+  const testTypeId = requireField(map, "test-type", "Test Type");
+  fields[testTypeId] = { value: opts.typeValue };
+  if (opts.type === "cucumber") {
+    const scenarioId = requireField(map, "cucumber-scenario", "Cucumber Scenario");
+    const cucumberTypeId = requireField(map, "cucumber-test-type", "Cucumber Test Type");
+    if (opts.gherkin !== void 0) fields[scenarioId] = opts.gherkin;
+    fields[cucumberTypeId] = { value: opts.cucumberType ?? "Scenario" };
+  } else if (opts.type === "generic") {
+    const defId = requireField(map, "generic-definition", "Generic Definition");
+    if (opts.definition !== void 0) fields[defId] = opts.definition;
+  }
+  if (opts.repositoryPath !== void 0) {
+    const pathId = requireField(map, "test-repository-path", "Test Repository Path");
+    fields[pathId] = opts.repositoryPath;
+  }
+  return fields;
+}
+function buildPreconditionCustomFields(map, opts) {
+  const fields = {};
+  const typeId = requireField(map, "precondition-type", "Pre-Condition Type");
+  fields[typeId] = { value: opts.typeValue };
+  if (opts.condition !== void 0) {
+    const bodyId = requireField(map, "precondition-body", "Conditions");
+    fields[bodyId] = opts.condition;
+  }
+  return fields;
+}
+
+// src/commands/xray/precondition/create.ts
+function create10(parent) {
+  const cmd = parent.command("create").description(
+    "Create a new Xray Pre-Condition issue. Note: the Pre-Condition issue type is only available in projects that have it configured (e.g. BD); it is not on the AI/QA scheme."
+  ).requiredOption("--project <key>", "Project key (e.g. BD)", text).requiredOption("--summary <text>", "Pre-Condition summary (title)", text).addOption(
+    new Option10("--type <type>", "Pre-Condition type").choices(["manual", "generic", "cucumber"]).default("manual")
+  );
+  textOrFileOption(cmd, "condition", { description: "Pre-condition body / definition text" });
+  textOrFileOption(cmd, "description", { description: "Pre-Condition issue description" });
+  examples(cmd, [
+    '--project BD --summary "User is logged in"',
+    '--project BD --summary "API key valid" --type generic --condition "apiKey != null"',
+    '--project BD --summary "Auth scenario" --type cucumber --condition "Given the user is authenticated"'
+  ]);
+  cmd.action(
+    async (opts) => {
+      const condition = resolveTextOrFile(opts, "condition", { required: false });
+      const description = resolveTextOrFile(opts, "description", { required: false });
+      const client = getClient();
+      const map = await resolveXrayFields(client);
+      const typeValue = await resolveTypeValue(client, {
+        projectKey: opts.project,
+        issueTypeName: XRAY_ISSUE_TYPES.PreCondition,
+        fieldConceptKey: "precondition-type",
+        type: opts.type,
+        fieldMap: map
+      });
+      const customFields = buildPreconditionCustomFields(map, { typeValue, condition });
+      const result = await createXrayIssue(client, {
+        project: opts.project,
+        type: XRAY_ISSUE_TYPES.PreCondition,
+        summary: opts.summary,
+        description,
+        customFields
+      });
+      output(transformCreatedIssue(result));
+    }
+  );
+}
+
+// src/commands/xray/precondition/delete.ts
+function deletePrecondition(parent) {
+  const cmd = parent.command("delete").description("Delete an Xray Pre-Condition issue").argument("<preKey>", "Pre-Condition issue key (e.g. BD-50)", issueKey);
+  examples(cmd, ["BD-50"]);
+  cmd.action(async (preKey) => {
+    const client = getClient();
+    await deleteXrayIssue(client, preKey);
+    output({ deleted: true, key: preKey });
+  });
+}
+
+// src/commands/xray/precondition/list.ts
+function list12(parent) {
+  const cmd = parent.command("list").description(
+    "List Pre-Conditions that apply to a given test (inverse view). For the forward view (tests covered by a precondition), use: xray precondition add/remove."
+  ).requiredOption("--test <key>", "Test issue key whose pre-conditions to list (e.g. AI-584)", issueKey);
+  examples(cmd, ["--test AI-584"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const preconditions = await client.xrayTests.getPreconditions({ testKey: opts.test });
+    output(transformLinks(preconditions));
+  });
+}
+
+// src/commands/xray/precondition/remove.ts
+function remove4(parent) {
+  const cmd = parent.command("remove").description("Remove tests from a Pre-Condition").argument("<preKey>", "Pre-Condition issue key (e.g. BD-50)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. AI-1,AI-2)", keyList);
+  examples(cmd, ["BD-50 --test AI-1", "BD-50 --test AI-1,AI-2"]);
+  cmd.action(async (preKey, opts) => {
+    const client = getClient();
+    const result = await client.preconditions.removeTests({ preKey, keys: opts.test });
+    output(result ?? { removed: true });
+  });
+}
+
+// src/commands/xray/precondition/update.ts
+import { Option as Option11 } from "commander";
+function update9(parent) {
+  const cmd = parent.command("update").description("Update an Xray Pre-Condition issue").argument("<preKey>", "Pre-Condition issue key (e.g. BD-50)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option11("--type <type>", "New Pre-Condition type").choices(["manual", "generic", "cucumber"]));
+  textOrFileOption(cmd, "condition", { description: "New pre-condition body / definition text" });
+  textOrFileOption(cmd, "description", { description: "New Pre-Condition issue description" });
+  examples(cmd, ['BD-50 --summary "Updated precondition"', 'BD-50 --type generic --condition "apiKey != null"']);
+  cmd.action(
+    async (preKey, opts) => {
+      const condition = resolveTextOrFile(opts, "condition", { required: false });
+      const description = resolveTextOrFile(opts, "description", { required: false });
+      const client = getClient();
+      let customFields;
+      if (opts.type !== void 0 || condition !== void 0) {
+        const map = await resolveXrayFields(client);
+        customFields = {};
+        if (opts.type !== void 0) {
+          const projectKey = preKey.split("-")[0];
+          const typeValue = await resolveTypeValue(client, {
+            projectKey,
+            issueTypeName: XRAY_ISSUE_TYPES.PreCondition,
+            fieldConceptKey: "precondition-type",
+            type: opts.type,
+            fieldMap: map
+          });
+          const typeId = map["precondition-type"];
+          if (!typeId) throw new Error("Xray field for 'Pre-Condition Type' not found on this instance.");
+          customFields[typeId] = { value: typeValue };
+        }
+        if (condition !== void 0) {
+          const bodyId = map["precondition-body"];
+          if (!bodyId) throw new Error("Xray field for 'Conditions' not found on this instance.");
+          customFields[bodyId] = condition;
+        }
+      }
+      await updateXrayIssue(client, preKey, { summary: opts.summary, description, customFields });
+      output({ key: preKey });
+    }
+  );
+}
+
+// src/commands/xray/precondition/index.ts
+function registerPreconditionCommands(xray) {
+  const precondition = xray.command("precondition").description(
+    "Xray Pre-Condition issue management (CRUD, membership). Note: Pre-Condition issue type is only available in projects where it is configured (not AI/QA). To list tests covered by a precondition, use: xray test list --precondition <key>."
+  );
+  examples(precondition, [
+    'create --project BD --summary "User is logged in"',
+    "add BD-50 --test QA-1,QA-2",
+    "list --test AI-584"
+  ]);
+  create10(precondition);
+  update9(precondition);
+  deletePrecondition(precondition);
+  add4(precondition);
+  remove4(precondition);
+  list12(precondition);
+}
+
+// src/utils/xray/run-id.ts
+async function resolveRunId(client, o) {
+  if (o.runId !== void 0) return o.runId;
+  if (!o.execution || !o.test) throw new Error("Provide a run id, or both --execution and --test to resolve the run.");
+  const run = await client.testRuns.resolve({ execKey: o.execution, testKey: o.test });
+  if (!run?.id) throw new Error(`No test run found for ${o.test} in ${o.execution}.`);
+  return Number(run.id);
+}
+
+// src/commands/xray/run/defect/add.ts
+function add5(parent) {
+  const cmd = parent.command("add").description("Link defect issues to a test run").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--defect <keys>", "Comma-separated defect issue keys to link", keyList).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42 --defect BUG-1", "--execution QA-1 --test QA-2 --defect BUG-1,BUG-2"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    await client.testRuns.addDefects({ runId: id, keys: opts.defect });
+    output({ runId: id, added: opts.defect });
+  });
+}
+
+// src/commands/xray/run/defect/remove.ts
+function remove5(parent) {
+  const cmd = parent.command("remove").description("Unlink defect issues from a test run (per-key, reports failures without aborting)").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--defect <keys>", "Comma-separated defect issue keys to unlink", keyList).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42 --defect BUG-1", "--execution QA-1 --test QA-2 --defect BUG-1,BUG-2"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    const results = await Promise.allSettled(
+      opts.defect.map((key) => client.testRuns.removeDefect({ runId: id, key }))
+    );
+    const removed = [];
+    const failed = [];
+    results.forEach((r, i) => {
+      const key = opts.defect[i];
+      if (r.status === "fulfilled") {
+        removed.push(key);
+      } else {
+        const reason = r.reason instanceof Error ? r.reason.message : String(r.reason);
+        failed.push({ key, reason });
+      }
+    });
+    output({
+      runId: id,
+      removed,
+      ...failed.length > 0 && { failed }
+    });
+    if (failed.length > 0) {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/xray/run/defect/index.ts
+function registerDefectCommands(run) {
+  const defect = run.command("defect").description(
+    "Manage defects linked to a test run. See also: run update --defect for the one-command fail+link loop."
+  );
+  examples(defect, ["add --execution QA-1 --test QA-2 --defect BUG-1", "remove 42 --defect BUG-1"]);
+  add5(defect);
+  remove5(defect);
+}
+
+// src/commands/xray/run/evidence/add.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { basename as basename4, extname } from "path";
+var CONTENT_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".xml": "application/xml",
+  ".json": "application/json",
+  ".zip": "application/zip",
+  ".html": "text/html",
+  ".log": "text/plain"
+};
+function inferContentType(fp) {
+  return CONTENT_TYPES[extname(fp).toLowerCase()] ?? "application/octet-stream";
+}
+function add6(parent) {
+  const cmd = parent.command("add").description("Attach a file as evidence to a test run").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--file <path>", "Path to the file to attach", filePath).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42 --file screenshot.png", "--execution QA-1 --test QA-2 --file report.pdf"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    const fileBuf = readFileSync6(opts.file);
+    const filename = basename4(opts.file);
+    const contentType = inferContentType(opts.file);
+    const data = fileBuf.toString("base64");
+    const result = await client.testRuns.addEvidence({ runId: id, data, filename, contentType });
+    output(result ?? { runId: id, attached: filename });
+  });
+}
+
+// src/commands/xray/run/evidence/delete.ts
+function deleteEvidence(parent) {
+  const cmd = parent.command("delete").description("Delete an evidence attachment from a test run").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--evidence-id <id>", "Id of the evidence attachment (from evidence list)", positiveInt).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42 --evidence-id 7", "--execution QA-1 --test QA-2 --evidence-id 7"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    await client.testRuns.deleteEvidence({ runId: id, evidenceId: opts.evidenceId });
+    output({ runId: id, evidenceId: opts.evidenceId, deleted: true });
+  });
+}
+
+// src/commands/xray/run/evidence/list.ts
+function list13(parent) {
+  const cmd = parent.command("list").description("List evidence (attachments) on a test run").argument("[runId]", "Test run id (from run list)", positiveInt).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42", "--execution QA-1 --test QA-2"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    const evidence = await client.testRuns.listEvidence({ runId: id });
+    output(transformEvidence(evidence));
+  });
+}
+
+// src/commands/xray/run/evidence/index.ts
+function registerEvidenceCommands(run) {
+  const evidence = run.command("evidence").description("Manage evidence (file attachments) on a test run");
+  examples(evidence, [
+    "add --execution QA-1 --test QA-2 --file screenshot.png",
+    "list 42",
+    "delete 42 --evidence-id 7"
+  ]);
+  add6(evidence);
+  list13(evidence);
+  deleteEvidence(evidence);
+}
+
+// src/commands/xray/run/field/get.ts
+function get4(parent) {
+  const cmd = parent.command("get").description("Get a custom field value on a test run").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--field-id <id>", "Custom field id (from xray field list)", text).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42 --field-id customfield_10100", "--execution QA-1 --test QA-2 --field-id customfield_10100"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    const result = await client.testRuns.getCustomField({ runId: id, fieldId: opts.fieldId });
+    output(result);
+  });
+}
+
+// src/commands/xray/run/field/set.ts
+function set(parent) {
+  const cmd = parent.command("set").description("Set a custom field value on a test run").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--field-id <id>", "Custom field id (from xray field list)", text).requiredOption("--value <text>", "Value to set for the field", text).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, [
+    '42 --field-id customfield_10100 --value "approved"',
+    '--execution QA-1 --test QA-2 --field-id customfield_10100 --value "reviewed"'
+  ]);
+  cmd.action(
+    async (runId, opts) => {
+      const client = getClient();
+      const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+      const result = await client.testRuns.setCustomField({ runId: id, fieldId: opts.fieldId, value: opts.value });
+      output(result ?? { runId: id, fieldId: opts.fieldId, value: opts.value, updated: true });
+    }
+  );
+}
+
+// src/commands/xray/run/field/index.ts
+function registerRunFieldCommands(run) {
+  const field = run.command("field").description("Get or set Xray custom field values on a test run");
+  examples(field, ["get 42 --field-id customfield_10100", 'set 42 --field-id customfield_10100 --value "approved"']);
+  get4(field);
+  set(field);
+}
+
+// src/commands/xray/run/get.ts
+function get5(parent) {
+  const cmd = parent.command("get").description("Get a test run by id or by execution + test key").argument("[runId]", "Test run id (from run list)", positiveInt).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42", "--execution QA-1 --test QA-2"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, ...opts });
+    const run = await client.testRuns.get({ runId: id });
+    output(transformRun(run));
+  });
+}
+
+// src/commands/xray/run/list.ts
+function list14(parent) {
+  const cmd = parent.command("list").description("List test runs for a test execution (CLI-side slice with --limit/--start)").requiredOption("--execution <key>", "Test execution issue key", issueKey).option("--limit <number>", "Max results to return (1-200)", intInRange(1, 200), 50).option("--start <number>", "Starting index for pagination", nonNegativeInt);
+  examples(cmd, ["--execution QA-1", "--execution QA-1 --limit 10", "--execution QA-1 --limit 10 --start 10"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const runs = await client.testRuns.listByExecution({ execKey: opts.execution });
+    const start = opts.start ?? 0;
+    const sliced = runs.slice(start, start + opts.limit);
+    output(sliced.map(transformRun));
+  });
+}
+
+// src/commands/xray/run/step/list.ts
+function list15(parent) {
+  const cmd = parent.command("list").description("List step results for a test run").argument("[runId]", "Test run id (from run list)", positiveInt).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  examples(cmd, ["42", "--execution QA-1 --test QA-2"]);
+  cmd.action(async (runId, opts) => {
+    const client = getClient();
+    const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+    const steps = await client.testRuns.listSteps({ runId: id });
+    output(transformRunSteps(steps));
+  });
+}
+
+// src/commands/xray/run/step/update.ts
+function update10(parent) {
+  const cmd = parent.command("update").description("Update a step result within a test run").argument("[runId]", "Test run id (from run list)", positiveInt).requiredOption("--step-id <id>", "Id of the step to update (from step list)", positiveInt).option(
+    "--status <status>",
+    "Step status (case-sensitive; run `xray status list --step` for valid values)",
+    nonEmpty
+  ).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey);
+  textOrFileOption(cmd, "comment", { description: "Comment text for this step result" });
+  textOrFileOption(cmd, "actual-result", { description: "Actual result text for this step" });
+  examples(cmd, [
+    "42 --step-id 1 --status PASS",
+    '--execution QA-1 --test QA-2 --step-id 2 --status FAIL --comment "button missing"',
+    '42 --step-id 1 --status PASS --actual-result "Form submitted successfully"'
+  ]);
+  cmd.action(
+    async (runId, opts) => {
+      const client = getClient();
+      const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+      const comment = resolveTextOrFile(opts, "comment", { required: false });
+      const actualResult = resolveTextOrFile(opts, "actualResult", { required: false });
+      const result = await client.testRuns.updateStep({
+        runId: id,
+        stepId: opts.stepId,
+        ...opts.status !== void 0 && { status: opts.status },
+        ...comment !== void 0 && { comment },
+        ...actualResult !== void 0 && { actualResult }
+      });
+      output(result ?? { runId: id, stepId: opts.stepId, updated: true });
+    }
+  );
+}
+
+// src/commands/xray/run/step/index.ts
+function registerRunStepCommands(run) {
+  const step = run.command("step").description("Manage step results within a test run. See also: xray step for test step definitions.");
+  examples(step, ["list --execution QA-1 --test QA-2", "update 42 --step-id 1 --status PASS"]);
+  list15(step);
+  update10(step);
+}
+
+// src/commands/xray/run/update.ts
+function update11(parent) {
+  const cmd = parent.command("update").description("Update a test run status, comment, assignee, or link defects").argument("[runId]", "Test run id (from run list)", positiveInt).option("--execution <key>", "Test execution issue key (used with --test to resolve run id)", issueKey).option("--test <key>", "Test issue key (used with --execution to resolve run id)", issueKey).option("--status <status>", "Run status (case-sensitive; run `xray status list` for valid values)", nonEmpty).option("--assignee <user>", "Assignee username", text).option("--defect <keys>", "Comma-separated defect issue keys to link", keyList);
+  textOrFileOption(cmd, "comment", { description: "Comment text for this run" });
+  examples(cmd, [
+    "42 --status PASS",
+    '--execution QA-1 --test QA-2 --status FAIL --comment "broken"',
+    '--execution QA-1 --test QA-2 --status FAIL --comment "broken" --defect BUG-1'
+  ]);
+  cmd.action(
+    async (runId, opts) => {
+      const client = getClient();
+      const id = await resolveRunId(client, { runId, execution: opts.execution, test: opts.test });
+      const comment = resolveTextOrFile(opts, "comment", { required: false });
+      const result = await client.testRuns.update({
+        runId: id,
+        ...opts.status !== void 0 && { status: opts.status },
+        ...comment !== void 0 && { comment },
+        ...opts.assignee !== void 0 && { assignee: opts.assignee }
+      });
+      if (opts.defect && opts.defect.length > 0) {
+        await client.testRuns.addDefects({ runId: id, keys: opts.defect });
+      }
+      output(result ?? { runId: id, updated: true });
+    }
+  );
+}
+
+// src/commands/xray/run/index.ts
+function registerRunCommands(xray) {
+  const run = xray.command("run").description(
+    "Manage test run results (status, comments, defects, evidence, steps). Every command accepts [runId] or --execution + --test."
+  );
+  examples(run, [
+    "get --execution QA-1 --test QA-2",
+    "list --execution QA-1",
+    'update --execution QA-1 --test QA-2 --status FAIL --comment "broken" --defect BUG-1',
+    "defect add 42 --defect BUG-1,BUG-2",
+    "evidence add --execution QA-1 --test QA-2 --file screenshot.png",
+    "step list --execution QA-1 --test QA-2",
+    "field get 42 --field-id customfield_10100"
+  ]);
+  get5(run);
+  list14(run);
+  update11(run);
+  registerDefectCommands(run);
+  registerEvidenceCommands(run);
+  registerRunStepCommands(run);
+  registerRunFieldCommands(run);
+}
+
+// src/commands/xray/status/list.ts
+function list16(parent) {
+  const cmd = parent.command("list").description("List configured Xray test (run) statuses").option("--step", "List test-step statuses instead of run statuses");
+  examples(cmd, ["", ["--step", "step statuses"]]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const data = opts.step ? await client.xraySettings.getStepStatuses() : await client.xraySettings.getTestStatuses();
+    output(transformStatuses(data));
+  });
+}
+
+// src/commands/xray/status/index.ts
+function registerStatusCommands(xray) {
+  const status = xray.command("status").description("Xray status discovery");
+  examples(status, ["list", ["list --step", "step statuses"]]);
+  list16(status);
+}
+
+// src/commands/xray/step/add.ts
+function add7(parent) {
+  const cmd = parent.command("add").description("Add a manual test step to a Test issue").requiredOption("--test <key>", "Test issue key (e.g. AI-584)", issueKey);
+  textOrFileOption(cmd, "action", { description: "Step action text (required: provide --action or --action-file)" });
+  textOrFileOption(cmd, "data", { description: "Step test data text" });
+  textOrFileOption(cmd, "result", { description: "Expected result text" });
+  examples(cmd, [
+    '--test AI-584 --action "Open login page" --result "Login form is shown"',
+    '--test AI-584 --action "Submit form" --data "user=admin" --result "Dashboard loads"'
+  ]);
+  cmd.action(
+    async (opts) => {
+      const action = resolveTextOrFile(opts, "action");
+      const data = resolveTextOrFile(opts, "data", { required: false });
+      const result = resolveTextOrFile(opts, "result", { required: false });
+      const client = getClient();
+      const ref = await client.testSteps.create({ testKey: opts.test, action, data, result });
+      output(ref);
+    }
+  );
+}
+
+// src/commands/xray/step/delete.ts
+function deleteStep(parent) {
+  const cmd = parent.command("delete").description("Delete a manual test step by ID").argument("<stepId>", "Step ID to delete (from step list)", positiveInt).requiredOption("--test <key>", "Test issue key (e.g. AI-584)", issueKey);
+  examples(cmd, ["3 --test AI-584"]);
+  cmd.action(async (stepId, opts) => {
+    const client = getClient();
+    await client.testSteps.delete({ testKey: opts.test, stepId });
+    output({ stepId, deleted: true });
+  });
+}
+
+// src/commands/xray/step/list.ts
+function list17(parent) {
+  const cmd = parent.command("list").description("List manual test steps for a Test issue").requiredOption("--test <key>", "Test issue key (e.g. AI-584)", issueKey);
+  examples(cmd, ["--test AI-584"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const steps = await client.testSteps.list({ testKey: opts.test });
+    output(steps.map(transformStep));
+  });
+}
+
+// src/commands/xray/step/update.ts
+function update12(parent) {
+  const cmd = parent.command("update").description("Update a manual test step by ID").argument("<stepId>", "Step ID to update (from step list)", positiveInt).requiredOption("--test <key>", "Test issue key (e.g. AI-584)", issueKey);
+  textOrFileOption(cmd, "action", { description: "New step action text" });
+  textOrFileOption(cmd, "data", { description: "New step test data text" });
+  textOrFileOption(cmd, "result", { description: "New expected result text" });
+  examples(cmd, [
+    '3 --test AI-584 --action "Click submit button"',
+    '3 --test AI-584 --result "Confirmation email sent"'
+  ]);
+  cmd.action(
+    async (stepId, opts) => {
+      const action = resolveTextOrFile(opts, "action", { required: false });
+      const data = resolveTextOrFile(opts, "data", { required: false });
+      const result = resolveTextOrFile(opts, "result", { required: false });
+      if (action === void 0 && data === void 0 && result === void 0) {
+        throw new Error(
+          "Provide at least one of --action (or --action-file), --data (or --data-file), --result (or --result-file)."
+        );
+      }
+      const client = getClient();
+      const res = await client.testSteps.update({ testKey: opts.test, stepId, action, data, result });
+      output(res ?? { stepId, updated: true });
+    }
+  );
+}
+
+// src/commands/xray/step/index.ts
+function registerStepCommands(xray) {
+  const step = xray.command("step").description(
+    "Manage manual test steps for a Test issue (scope: --test). Steps are ordered by insertion; use step list to see current ids."
+  );
+  examples(step, ['add --test AI-584 --action "Open login" --result "Form shows"', "list --test AI-584"]);
+  list17(step);
+  add7(step);
+  update12(step);
+  deleteStep(step);
+}
+
+// src/commands/xray/test/create.ts
+import { Option as Option12 } from "commander";
+import { z as z4 } from "zod";
+var stepsSchema = z4.array(
+  z4.object({ action: z4.string(), data: z4.string().optional(), result: z4.string().optional() })
+);
+function create11(parent) {
+  const cmd = parent.command("create").description("Create a new Xray Test issue").requiredOption("--project <key>", "Project key (e.g. AI)", text).requiredOption("--summary <text>", "Test summary (title)", text).addOption(
+    new Option12("--type <type>", "Test type (when cucumber: also pass --gherkin; when generic: --definition)").choices(["manual", "cucumber", "generic"]).default("manual")
+  ).addOption(
+    new Option12("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
+      "scenario",
+      "scenario-outline"
+    ])
+  ).option("--labels <labels>", "Comma-separated labels", text).option("--components <names>", "Comma-separated component names", text).option("--assignee <user>", 'Assignee username or "me"', text).option("--reporter <user>", 'Reporter username or "me"', text).option("--steps <json>", "JSON array of manual steps to seed: [{action,data?,result?}]", jsonShape(stepsSchema));
+  textOrFileOption(cmd, "gherkin", { description: "Gherkin scenario text (required when --type cucumber)" });
+  textOrFileOption(cmd, "definition", { description: "Generic test definition (required when --type generic)" });
+  textOrFileOption(cmd, "description", { description: "Test description" });
+  examples(cmd, [
+    [
+      `--project AI --summary "Login test" --type manual --steps '[{"action":"Open browser","result":"Browser opens"}]'`,
+      "Create manual test with step seed"
+    ],
+    [
+      '--project AI --summary "Login scenario" --type cucumber --cucumber-type scenario --gherkin "Given I am on login page\\nWhen I enter credentials\\nThen I am logged in"',
+      "Create cucumber test"
+    ],
+    [
+      '--project AI --summary "Perf baseline" --type generic --definition "Run k6 script and assert p95 < 500ms"',
+      "Create generic test"
+    ]
+  ]);
+  cmd.action(
+    async (opts) => {
+      const gherkin = resolveTextOrFile(opts, "gherkin", { required: false });
+      const definition = resolveTextOrFile(opts, "definition", { required: false });
+      const description = resolveTextOrFile(opts, "description", { required: false });
+      if (opts.type === "cucumber" && !gherkin) {
+        throw new Error("--gherkin (or --gherkin-file) is required when --type is cucumber.");
+      }
+      if (opts.type === "generic" && !definition) {
+        throw new Error("--definition (or --definition-file) is required when --type is generic.");
+      }
+      const cucumberType = opts.cucumberType === "scenario" ? "Scenario" : opts.cucumberType === "scenario-outline" ? "Scenario Outline" : void 0;
+      const client = getClient();
+      const xrayFields = await resolveXrayFields(client);
+      const typeValue = await resolveTypeValue(client, {
+        projectKey: opts.project,
+        issueTypeName: XRAY_ISSUE_TYPES.Test,
+        fieldConceptKey: "test-type",
+        type: opts.type,
+        fieldMap: xrayFields
+      });
+      const customFields = buildTestCustomFields(xrayFields, {
+        type: opts.type,
+        typeValue,
+        cucumberType,
+        gherkin,
+        definition
+      });
+      const assignee = opts.assignee !== void 0 ? await resolveUserToken(opts.assignee) : void 0;
+      const reporter = opts.reporter !== void 0 ? await resolveUserToken(opts.reporter) : void 0;
+      const result = await client.issues.create({
+        projectKeyOrId: opts.project,
+        issueTypeName: XRAY_ISSUE_TYPES.Test,
+        summary: opts.summary,
+        description,
+        assignee: assignee ?? void 0,
+        reporter: reporter ?? void 0,
+        labels: opts.labels?.split(",").map((l) => l.trim()),
+        components: opts.components?.split(",").map((c) => c.trim()),
+        customFields
+      });
+      if (opts.steps) {
+        for (const step of opts.steps) {
+          await client.testSteps.create({ testKey: result.key, ...step });
+        }
+      }
+      output(transformCreatedIssue(result));
+    }
+  );
+}
+
+// src/commands/xray/test/delete.ts
+function deleteTest(parent) {
+  const cmd = parent.command("delete").description("Delete an Xray Test issue").argument("<testKey>", "Test issue key (e.g. AI-584)", issueKey);
+  examples(cmd, ["AI-584"]);
+  cmd.action(async (testKey) => {
+    const client = getClient();
+    await client.issues.delete({ issueKeyOrId: testKey });
+    output({ deleted: true, key: testKey });
+  });
+}
+
+// src/commands/xray/test/get.ts
+function get6(parent) {
+  const cmd = parent.command("get").description("Get one or more Xray test issues by key").argument("<testKey...>", "One or more test issue keys (e.g. AI-584)", listOf(issueKey));
+  examples(cmd, ["AI-584", "AI-584 AI-585"]);
+  cmd.action(async (testKeys) => {
+    const client = getClient();
+    const tests = await client.xrayTests.getTests({ keys: testKeys });
+    output(tests.map(transformTest));
+  });
+}
+
+// src/commands/xray/test/list.ts
+function list18(parent) {
+  const cmd = parent.command("list").description(
+    "List Xray Test issues by scope: all tests in a project, or tests belonging to a set, plan, execution, precondition, or folder. Note: use `jiradc issue search` for richer JQL when scoping by project."
+  ).option("--project <text>", "Project key \u2014 list all tests in the project (or companion to --folder)", text).option("--set <key>", "Test Set issue key \u2014 list tests in this set", issueKey).option("--plan <key>", "Test Plan issue key \u2014 list tests in this plan", issueKey).option("--execution <key>", "Test Execution issue key \u2014 list tests in this execution", issueKey).option("--precondition <key>", "Precondition issue key \u2014 list tests with this precondition", issueKey).option("--folder <id>", "Folder id \u2014 list tests in this folder (requires --project)", positiveInt).option("--limit <number>", "Max results (1-50, applies to --project scope)", intInRange(1, 50), 25).option("--start <number>", "Starting index for pagination (applies to --project scope)", nonNegativeInt);
+  examples(cmd, ["--project QA", "--set QA-100", "--folder 818 --project QA"]);
+  cmd.action(
+    async (opts) => {
+      const client = getClient();
+      if (opts.folder !== void 0) {
+        if (!opts.project) {
+          throw new Error("--project is required when --folder is specified.");
+        }
+        const otherScopes = ["set", "plan", "execution", "precondition"].filter(
+          (k) => opts[k] !== void 0
+        );
+        if (otherScopes.length > 0) {
+          throw new Error(
+            `--folder cannot be combined with ${otherScopes.map((k) => `--${k}`).join(", ")}. Use --folder with --project only.`
+          );
+        }
+        const result2 = await client.testRepository.getFolderTests({
+          projectKey: opts.project,
+          folderId: opts.folder
+        });
+        output(transformTestList(result2));
+        return;
+      }
+      const scope = assertExactlyOne(
+        opts,
+        ["project", "set", "plan", "execution", "precondition"],
+        "test scope"
+      );
+      if (scope === "project") {
+        const result2 = await client.issues.search({
+          jql: `project=${opts.project} AND issuetype=Test`,
+          startAt: opts.start,
+          maxResults: opts.limit
+        });
+        const issues3 = result2.issues.map((i) => ({
+          key: i.key,
+          ...i.fields?.summary !== void 0 && { summary: i.fields.summary },
+          ...i.fields?.status?.name !== void 0 && { status: i.fields.status.name }
+        }));
+        output({
+          total: result2.total,
+          startAt: result2.startAt,
+          maxResults: result2.maxResults,
+          isLast: result2.startAt + issues3.length >= result2.total,
+          issues: issues3
+        });
+        return;
+      }
+      if (scope === "set") {
+        const result2 = await client.testSets.listTests({ setKey: opts.set });
+        output(transformTestList(result2));
+        return;
+      }
+      if (scope === "plan") {
+        const result2 = await client.testPlans.listTests({ planKey: opts.plan });
+        output(transformTestList(result2));
+        return;
+      }
+      if (scope === "execution") {
+        const result2 = await client.testExecutions.listTests({ execKey: opts.execution });
+        output(transformTestList(result2));
+        return;
+      }
+      const result = await client.preconditions.listTests({ preKey: opts.precondition });
+      output(transformTestList(result));
+    }
+  );
+}
+
+// src/commands/xray/test/update.ts
+import { Option as Option13 } from "commander";
+function update13(parent) {
+  const cmd = parent.command("update").description("Update an Xray Test issue").argument("<testKey>", "Test issue key (e.g. AI-584)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option13("--type <type>", "Test type").choices(["manual", "cucumber", "generic"])).addOption(
+    new Option13("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
+      "scenario",
+      "scenario-outline"
+    ])
+  ).option("--labels <labels>", "Comma-separated labels", text).option("--components <names>", "Comma-separated component names", text).option("--assignee <user>", 'Assignee username or "me"', text).option("--reporter <user>", 'Reporter username or "me"', text);
+  textOrFileOption(cmd, "gherkin", { description: "Gherkin scenario text (required when --type cucumber)" });
+  textOrFileOption(cmd, "definition", { description: "Generic test definition (required when --type generic)" });
+  textOrFileOption(cmd, "description", { description: "Test description" });
+  examples(cmd, [
+    'AI-584 --summary "Updated title"',
+    'AI-584 --type cucumber --cucumber-type scenario --gherkin "Given I open the app"'
+  ]);
+  cmd.action(
+    async (testKey, opts) => {
+      const gherkin = resolveTextOrFile(opts, "gherkin", { required: false });
+      const definition = resolveTextOrFile(opts, "definition", { required: false });
+      const description = resolveTextOrFile(opts, "description", { required: false });
+      const fields = {};
+      if (opts.summary !== void 0) fields.summary = opts.summary;
+      if (description !== void 0) fields.description = description;
+      if (opts.labels !== void 0) fields.labels = opts.labels.split(",").map((l) => l.trim());
+      if (opts.components !== void 0)
+        fields.components = opts.components.split(",").map((c) => c.trim()).map((name) => ({ name }));
+      const client = getClient();
+      if (opts.assignee !== void 0) {
+        const resolved = await resolveUserToken(opts.assignee);
+        fields.assignee = resolved === null ? null : { name: resolved };
+      }
+      if (opts.reporter !== void 0) fields.reporter = { name: opts.reporter };
+      if (opts.type !== void 0) {
+        if (opts.type === "cucumber" && !gherkin) {
+          throw new Error("--gherkin (or --gherkin-file) is required when --type is cucumber.");
+        }
+        if (opts.type === "generic" && !definition) {
+          throw new Error("--definition (or --definition-file) is required when --type is generic.");
+        }
+        const cucumberType = opts.cucumberType === "scenario" ? "Scenario" : opts.cucumberType === "scenario-outline" ? "Scenario Outline" : void 0;
+        const projectKey = testKey.split("-")[0];
+        const xrayFields = await resolveXrayFields(client);
+        const typeValue = await resolveTypeValue(client, {
+          projectKey,
+          issueTypeName: XRAY_ISSUE_TYPES.Test,
+          fieldConceptKey: "test-type",
+          type: opts.type,
+          fieldMap: xrayFields
+        });
+        const customFields = buildTestCustomFields(xrayFields, {
+          type: opts.type,
+          typeValue,
+          cucumberType,
+          gherkin,
+          definition
+        });
+        Object.assign(fields, customFields);
+      }
+      await client.issues.update({ issueKeyOrId: testKey, fields });
+      output({ key: testKey });
+    }
+  );
+}
+
+// src/commands/xray/test/index.ts
+function registerTestCommands(xray) {
+  const test = xray.command("test").description("Xray Test issue management (CRUD)");
+  examples(test, ["get AI-584", 'create --project AI --summary "Login" --type manual']);
+  get6(test);
+  create11(test);
+  update13(test);
+  deleteTest(test);
+  list18(test);
+}
+
+// src/commands/xray/testset/add.ts
+function add8(parent) {
+  const cmd = parent.command("add").description("Add tests to a Test Set").argument("<setKey>", "Test Set issue key (e.g. AI-100)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to add (e.g. AI-1,AI-2)", keyList);
+  examples(cmd, ["AI-100 --test AI-1", "AI-100 --test AI-1,AI-2,AI-3"]);
+  cmd.action(async (setKey, opts) => {
+    const client = getClient();
+    const result = await client.testSets.addTests({ setKey, keys: opts.test });
+    output(result ?? { added: true });
+  });
+}
+
+// src/commands/xray/testset/create.ts
+function create12(parent) {
+  const cmd = parent.command("create").description("Create a new Xray Test Set issue").requiredOption("--project <key>", "Project key (e.g. AI)", text).requiredOption("--summary <text>", "Test Set summary (title)", text);
+  textOrFileOption(cmd, "description", { description: "Test Set description" });
+  examples(cmd, [
+    '--project AI --summary "Smoke Test Set"',
+    '--project AI --summary "Regression Set" --description "All regression tests"'
+  ]);
+  cmd.action(async (opts) => {
+    const description = resolveTextOrFile(opts, "description", { required: false });
+    const client = getClient();
+    const result = await createXrayIssue(client, {
+      project: opts.project,
+      type: XRAY_ISSUE_TYPES.TestSet,
+      summary: opts.summary,
+      description
+    });
+    output(transformCreatedIssue(result));
+  });
+}
+
+// src/commands/xray/testset/delete.ts
+function deleteTestset(parent) {
+  const cmd = parent.command("delete").description("Delete an Xray Test Set issue").argument("<setKey>", "Test Set issue key (e.g. AI-100)", issueKey);
+  examples(cmd, ["AI-100"]);
+  cmd.action(async (setKey) => {
+    const client = getClient();
+    await deleteXrayIssue(client, setKey);
+    output({ deleted: true, key: setKey });
+  });
+}
+
+// src/commands/xray/testset/list.ts
+function list19(parent) {
+  const cmd = parent.command("list").description(
+    "List Test Sets that contain a given test (inverse view). For the forward view (tests inside a set), use: xray test list --set <key>"
+  ).requiredOption("--test <key>", "Test issue key whose sets to list (e.g. AI-584)", issueKey);
+  examples(cmd, ["--test AI-584"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const sets = await client.xrayTests.getTestSets({ testKey: opts.test });
+    output(transformLinks(sets));
+  });
+}
+
+// src/commands/xray/testset/remove.ts
+function remove6(parent) {
+  const cmd = parent.command("remove").description("Remove tests from a Test Set").argument("<setKey>", "Test Set issue key (e.g. AI-100)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. AI-1,AI-2)", keyList);
+  examples(cmd, ["AI-100 --test AI-1", "AI-100 --test AI-1,AI-2"]);
+  cmd.action(async (setKey, opts) => {
+    const client = getClient();
+    const result = await client.testSets.removeTests({ setKey, keys: opts.test });
+    output(result ?? { removed: true });
+  });
+}
+
+// src/commands/xray/testset/update.ts
+function update14(parent) {
+  const cmd = parent.command("update").description("Update an Xray Test Set issue").argument("<setKey>", "Test Set issue key (e.g. AI-100)", issueKey).option("--summary <text>", "New summary (title)", text);
+  textOrFileOption(cmd, "description", { description: "New Test Set description" });
+  examples(cmd, ['AI-100 --summary "Updated smoke set"', 'AI-100 --description "New description"']);
+  cmd.action(async (setKey, opts) => {
+    const description = resolveTextOrFile(opts, "description", { required: false });
+    const client = getClient();
+    await updateXrayIssue(client, setKey, { summary: opts.summary, description });
+    output({ key: setKey });
+  });
+}
+
+// src/commands/xray/testset/index.ts
+function registerTestsetCommands(xray) {
+  const testset = xray.command("testset").description(
+    "Xray Test Set issue management (CRUD, membership). To list tests inside a set, use: xray test list --set <key>"
+  );
+  examples(testset, ['create --project AI --summary "Smoke tests"', "add QA-100 --test QA-1,QA-2"]);
+  create12(testset);
+  update14(testset);
+  deleteTestset(testset);
+  add8(testset);
+  remove6(testset);
+  list19(testset);
+}
+
+// src/commands/xray/index.ts
+function registerXrayCommands(program) {
+  const xray = program.command("xray").description("Xray test management (tests, runs, repository, import/export)");
+  examples(xray, ["test get AI-584"]);
+  registerStatusCommands(xray);
+  registerFieldCommands2(xray);
+  registerTestCommands(xray);
+  registerTestsetCommands(xray);
+  registerPreconditionCommands(xray);
+  registerExecutionCommands(xray);
+  registerPlanCommands(xray);
+  registerStepCommands(xray);
+  registerRunCommands(xray);
+  registerFolderCommands(xray);
+  registerImportCommands(xray);
+  registerExportCommands(xray);
+}
+
 // src/program.ts
 var DIM = "\x1B[2m";
 var RESET = "\x1B[0m";
 function buildProgram() {
-  const program = new Command11();
+  const program = new Command16();
   program.name("jiradc").description("Jira Data Center CLI").version(readPackageVersion(import.meta.url)).configureHelp({
     styleTitle: (str) => styleText("bold", str),
     styleUsage: (str) => styleText("dim", str),
@@ -2288,6 +3945,7 @@ ${styleText("bold", "Examples:")}
   registerFieldCommands(program);
   registerUserCommands(program);
   registerTokenCommands(program);
+  registerXrayCommands(program);
   return program;
 }