jiradc-cli 1.0.39 → 1.0.41

package/dist/index.js

@@ -1,688 +1,31 @@
 #!/usr/bin/env node
-
-// ../../cli-utils/dist/cache.js
-import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_TTL = 36e5;
-function getCacheDir(name) {
-  return join(homedir(), ".cache", name);
-}
-function getCachePath(name, key) {
-  return join(getCacheDir(name), `${key}.json`);
-}
-function cacheGet(options, key) {
-  const ttl = options.ttl ?? DEFAULT_TTL;
-  const path = getCachePath(options.name, key);
-  try {
-    const stat = statSync(path);
-    if (Date.now() - stat.mtimeMs > ttl)
-      return null;
-    const raw = readFileSync(path, "utf-8");
-    const entry = JSON.parse(raw);
-    return entry.data;
-  } catch {
-    return null;
-  }
-}
-function cacheSet(options, key, data) {
-  const dir = getCacheDir(options.name);
-  const path = getCachePath(options.name, key);
-  const entry = { data, timestamp: Date.now() };
-  try {
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(path, JSON.stringify(entry));
-  } catch {
-  }
-}
-async function cacheGetOrFetch(options, key, fetcher) {
-  const cached = cacheGet(options, key);
-  if (cached !== null)
-    return cached;
-  const data = await fetcher();
-  cacheSet(options, key, data);
-  return data;
-}
-
-// ../../cli-utils/dist/bootstrap.js
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
-function readPackageVersion(importMetaUrl) {
-  try {
-    const here = dirname(fileURLToPath(importMetaUrl));
-    const pkg = JSON.parse(readFileSync2(join2(here, "..", "package.json"), "utf-8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-// ../../cli-utils/dist/validators.js
-import { InvalidArgumentError } from "commander";
-function intInRange(min, max) {
-  return (raw) => {
-    const n = parseInt(raw, 10);
-    if (Number.isNaN(n) || !Number.isFinite(n)) {
-      throw new InvalidArgumentError("Must be an integer.");
-    }
-    if (n < min || n > max) {
-      throw new InvalidArgumentError(`Must be between ${min} and ${max}.`);
-    }
-    return n;
-  };
-}
-function nonNegativeInt(raw) {
-  const n = parseInt(raw, 10);
-  if (Number.isNaN(n) || n < 0) {
-    throw new InvalidArgumentError("Must be a non-negative integer.");
-  }
-  return n;
-}
-function positiveInt(raw) {
-  const n = parseInt(raw, 10);
-  if (Number.isNaN(n) || n < 1) {
-    throw new InvalidArgumentError("Must be a positive integer.");
-  }
-  return n;
-}
-function listOf(item) {
-  return (raw, previous) => [...Array.isArray(previous) ? previous : [], item(raw)];
-}
-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) {
-    throw new InvalidArgumentError("Must be a date in YYYY-MM-DD format.");
-  }
-  const [, y, mo, d] = m;
-  const year = Number(y);
-  const month = Number(mo);
-  const day = Number(d);
-  const dt = new Date(Date.UTC(year, month - 1, day));
-  if (dt.getUTCFullYear() !== year || dt.getUTCMonth() !== month - 1 || dt.getUTCDate() !== day) {
-    throw new InvalidArgumentError("Not a real calendar date.");
-  }
-  return raw;
-}
-function dateTime(raw) {
-  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(raw) || Number.isNaN(Date.parse(raw))) {
-    throw new InvalidArgumentError("Must be an ISO 8601 date-time, e.g. 2026-06-08T14:30:00Z.");
-  }
-  return raw;
-}
-
-// ../../cli-utils/dist/json.js
-import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
-function jsonShape(schema) {
-  return (raw) => {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new InvalidArgumentError2("Must be valid JSON.");
-    }
-    const result = schema.safeParse(parsed);
-    if (!result.success) {
-      const issues3 = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
-      throw new InvalidArgumentError2(`Invalid JSON shape \u2014 ${issues3}`);
-    }
-    return result.data;
-  };
-}
-
-// ../../cli-utils/dist/text-or-file.js
-import { readFileSync as readFileSync3 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError3, Option } from "commander";
-var STDIN_REF = "-";
-function rejectStdinSentinel(value) {
-  if (value === "@-" || value === STDIN_REF) {
-    throw new InvalidArgumentError3(`"${value}" looks like a stdin redirect, which is not supported here. Pass the text directly, or read it from a file/stdin with the matching --\u2026-file <path|-> option.`);
-  }
-  return value;
-}
-function readFileOrStdin(ref) {
-  if (ref === STDIN_REF) {
-    if (process.stdin.isTTY) {
-      throw new InvalidArgumentError3('"--\u2026-file -" reads stdin, but stdin is a terminal (nothing piped).');
-    }
-    try {
-      return readFileSync3(0, "utf8");
-    } catch (err) {
-      throw new InvalidArgumentError3(`failed to read stdin for "--\u2026-file -": ${err.message}`);
-    }
-  }
-  try {
-    return readFileSync3(ref, "utf8");
-  } catch (err) {
-    const e = err;
-    if (e.code === "ENOENT") {
-      throw new InvalidArgumentError3(`file not found: "${ref}".`);
-    }
-    throw new InvalidArgumentError3(`failed to read file "${ref}": ${e.message}`);
-  }
-}
-function textOrFileOption(cmd, name, opts = {}) {
-  const label = `${name.charAt(0).toUpperCase()}${name.slice(1)} content`;
-  cmd.option(`--${name} <text>`, opts.description ?? label, rejectStdinSentinel);
-  cmd.addOption(new Option(`--${name}-file <path>`, `Read --${name} from a file, or "-" for stdin (mutually exclusive with --${name})`).conflicts(name).argParser(text));
-  return cmd;
-}
-function resolveTextOrFile(opts, name, { required = true } = {}) {
-  const record = opts;
-  const literal = record[name];
-  const ref = record[`${name}File`];
-  if (literal !== void 0 && ref !== void 0) {
-    throw new InvalidArgumentError3(`--${name} and --${name}-file are mutually exclusive; provide only one.`);
-  }
-  if (ref !== void 0) {
-    return readFileOrStdin(ref);
-  }
-  if (literal === void 0 && required) {
-    throw new InvalidArgumentError3(`a ${name} is required: provide --${name} <text> or --${name}-file <path>.`);
-  }
-  return literal;
-}
-
-// ../../cli-utils/dist/registry.js
-var SUB_ENTITY_ID_NUMERIC = {
-  comment: true,
-  worklog: true,
-  attachment: true,
-  request: true,
-  type: true,
-  employee: true,
-  message: false,
-  membership: false
-};
-
-// ../../cli-utils/dist/builders.js
-function defineOption(cmd, flags, description, parser, mandatory) {
-  if (mandatory) {
-    return parser ? cmd.requiredOption(flags, description, parser) : cmd.requiredOption(flags, description);
-  }
-  return parser ? cmd.option(flags, description, parser) : cmd.option(flags, description);
-}
-function subjectArg(cmd, name, opts = {}) {
-  const inner = opts.variadic ? `${name}...` : name;
-  const token = opts.optional ? `[${inner}]` : `<${inner}>`;
-  return opts.parser ? cmd.argument(token, opts.description ?? "", opts.parser) : cmd.argument(token, opts.description ?? "");
-}
-function subEntityOption(cmd, entity, opts = {}) {
-  const numeric = opts.numeric ?? SUB_ENTITY_ID_NUMERIC[entity] ?? true;
-  const description = `${entity.charAt(0).toUpperCase()}${entity.slice(1)} id`;
-  return defineOption(cmd, `--${entity}-id <id>`, description, numeric ? positiveInt : text, opts.mandatory);
-}
-function paginationOptions(cmd, opts = {}) {
-  const max = opts.maxLimit ?? 1e3;
-  const def = opts.defaultLimit ?? 25;
-  cmd.option("--limit <n>", `Max results per page (1-${max})`, intInRange(1, max), def);
-  if (opts.startIsToken) {
-    cmd.option("--start <indexOrToken>", "Pagination cursor: 0-based offset or opaque next-page token", text);
-  } else {
-    cmd.option("--start <index>", "Pagination offset (0-based)", nonNegativeInt);
-  }
-  return cmd;
-}
-function bodyOption(cmd, opts = {}) {
-  return textOrFileOption(cmd, "body", { description: "Prose body content", ...opts });
-}
-function commentOption(cmd, opts = {}) {
-  return textOrFileOption(cmd, "comment", { description: "Optional note attached to the action", ...opts });
-}
-var EXAMPLES = /* @__PURE__ */ new WeakSet();
-function commandPath(cmd) {
-  const parts = [];
-  for (let c = cmd; c; c = c.parent)
-    parts.unshift(c.name());
-  return parts.join(" ");
-}
-function exampleLine(path, entry) {
-  if (typeof entry === "string")
-    return entry ? `  ${path} ${entry}` : `  ${path}`;
-  if ("raw" in entry)
-    return `  ${entry.raw}`;
-  const [args, comment] = entry;
-  const line = args ? `${path} ${args}` : path;
-  return `  ${line}  # ${comment}`;
-}
-function examples(cmd, entries) {
-  EXAMPLES.add(cmd);
-  return cmd.addHelpText("after", () => {
-    const path = commandPath(cmd);
-    return `
-Examples:
-${entries.map((e) => exampleLine(path, e)).join("\n")}`;
-  });
-}
-
-// ../../cli-utils/dist/errors.js
-import { CommanderError } from "commander";
-var EXIT = {
-  SUCCESS: 0,
-  GENERIC: 1,
-  USAGE: 2,
-  NOT_FOUND: 3,
-  FORBIDDEN: 4,
-  CONFLICT: 5,
-  AUTH: 6
-};
-var CliAuthError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CliAuthError";
-  }
-};
-var NOT_FOUND_RECOVERY = "Verify the id/key, then check your access.";
-var NOT_FOUND_MESSAGE = "Not found: it may not exist, or you may not have permission to see it";
-var USAGE_RECOVERY = "Check the command syntax and flags; run the command with --help.";
-var CliNotFoundError = class extends Error {
-  recovery;
-  constructor(message, recovery = NOT_FOUND_RECOVERY) {
-    super(message);
-    this.name = "CliNotFoundError";
-    this.recovery = recovery;
-  }
-};
-var CliUsageError = class extends Error {
-  recovery;
-  detail;
-  constructor(message, recovery = USAGE_RECOVERY, detail) {
-    super(message);
-    this.name = "CliUsageError";
-    this.recovery = recovery;
-    this.detail = detail;
-  }
-};
-var SubcommandRequiredError = class extends Error {
-  subcommands;
-  constructor(commandPath3, subcommands) {
-    super(`'${commandPath3}' requires a subcommand`);
-    this.name = "SubcommandRequiredError";
-    this.subcommands = subcommands;
-  }
-};
-var UnknownSubcommandError = class extends Error {
-  subcommands;
-  suggestion;
-  constructor(commandPath3, token, subcommands, suggestion) {
-    super(`'${token}' is not a subcommand of '${commandPath3}'`);
-    this.name = "UnknownSubcommandError";
-    this.subcommands = subcommands;
-    this.suggestion = suggestion;
-  }
-};
-var TYPE_EXIT = {
-  usage: EXIT.USAGE,
-  not_found: EXIT.NOT_FOUND,
-  forbidden: EXIT.FORBIDDEN,
-  conflict: EXIT.CONFLICT,
-  auth: EXIT.AUTH,
-  rate_limited: EXIT.GENERIC,
-  server: EXIT.GENERIC,
-  timeout: EXIT.GENERIC,
-  network: EXIT.GENERIC,
-  unknown: EXIT.GENERIC
-};
-var TRANSPORT_CODES = {
-  /** Our own timeout fired: connected (or tried to), no response in time. */
-  readTimeout: ["ECONNABORTED"],
-  /** The OS gave up establishing the connection. */
-  connectTimeout: ["ETIMEDOUT"],
-  /** No such host, or DNS itself is unavailable. */
-  unresolved: ["ENOTFOUND", "EAI_AGAIN"],
-  /** Host is there, nothing is listening on that port. */
-  refused: ["ECONNREFUSED"],
-  /** Established, then died mid-flight. */
-  dropped: ["ECONNRESET", "EPIPE"]
-};
-function humanMs(ms) {
-  return ms % 1e3 === 0 ? `${ms / 1e3}s` : `${ms}ms`;
-}
-function targetHost(err) {
-  const config = err?.config;
-  const raw = config?.baseURL ?? config?.url;
-  if (raw === void 0 || raw === "")
-    return void 0;
-  try {
-    return new URL(raw).host;
-  } catch {
-    return void 0;
-  }
-}
-function configuredTimeoutMs(err) {
-  const t = err?.config?.timeout;
-  return typeof t === "number" && t > 0 ? t : void 0;
-}
-function retryAfterSeconds(err) {
-  const headers = err?.response?.headers;
-  const raw = headers?.["retry-after"];
-  if (raw === void 0 || raw === "")
-    return void 0;
-  const seconds = Number(raw);
-  if (Number.isFinite(seconds))
-    return Math.max(0, Math.round(seconds));
-  if (typeof raw !== "string")
-    return void 0;
-  const at = Date.parse(raw);
-  if (Number.isNaN(at))
-    return void 0;
-  return Math.max(0, Math.round((at - Date.now()) / 1e3));
-}
-function httpStatus(err) {
-  const e = err;
-  return e?.response?.status ?? e?.statusCode;
-}
-function responseDetail(err) {
-  const e = err;
-  const data = e?.response?.data;
-  if (data && typeof data === "object")
-    return data;
-  const body = e?.body;
-  if (typeof body === "string") {
-    try {
-      const parsed = JSON.parse(body);
-      return parsed.error ?? parsed;
-    } catch {
-      return void 0;
-    }
-  }
-  if (body && typeof body === "object") {
-    return body.error ?? body;
-  }
-  return void 0;
-}
-function errorCode(err) {
-  return err?.code;
-}
-function normalize(err, opts) {
-  const message = err instanceof Error ? err.message : String(err);
-  if (err instanceof CommanderError) {
-    return {
-      type: "usage",
-      message: (message || "Invalid command usage").replace(/^error:\s+/, ""),
-      recovery: "Check the command syntax and flags; run the command with --help.",
-      retryable: false
-    };
-  }
-  if (err instanceof SubcommandRequiredError) {
-    return {
-      type: "usage",
-      message,
-      recovery: `Re-run with one of these subcommands: ${err.subcommands.join(", ")}.`,
-      retryable: false,
-      detail: { subcommands: err.subcommands }
-    };
-  }
-  if (err instanceof UnknownSubcommandError) {
-    const didYouMean = err.suggestion === void 0 ? "" : `Did you mean '${err.suggestion}'? `;
-    return {
-      type: "usage",
-      message,
-      recovery: `${didYouMean}Valid subcommands: ${err.subcommands.join(", ")}.`,
-      retryable: false,
-      detail: { subcommands: err.subcommands }
-    };
-  }
-  if (err instanceof CliAuthError) {
-    return { type: "auth", message: message || "Missing credentials", recovery: opts.authRecovery, retryable: false };
-  }
-  if (err instanceof CliNotFoundError) {
-    return { type: "not_found", message, recovery: err.recovery, retryable: false };
-  }
-  if (err instanceof CliUsageError) {
-    return {
-      type: "usage",
-      message,
-      recovery: err.recovery,
-      retryable: false,
-      ...err.detail !== void 0 ? { detail: err.detail } : {}
-    };
-  }
-  const status = httpStatus(err);
-  const detail = responseDetail(err);
-  if (status !== void 0) {
-    switch (status) {
-      case 400:
-        return {
-          type: "usage",
-          status,
-          message: "Bad request",
-          recovery: "Check parameter values (ids, keys, query syntax) against the API.",
-          retryable: false,
-          detail
-        };
-      case 401:
-        return {
-          type: "auth",
-          status,
-          message: "Authentication failed",
-          recovery: opts.authRecovery,
-          retryable: false
-        };
-      case 403:
-        return {
-          type: "forbidden",
-          status,
-          message: "Forbidden",
-          recovery: `Your ${opts.service} account lacks permission for this operation; check token scope and resource permissions.`,
-          retryable: false,
-          detail
-        };
-      case 404:
-        return {
-          type: "not_found",
-          status,
-          message: NOT_FOUND_MESSAGE,
-          recovery: NOT_FOUND_RECOVERY,
-          retryable: false,
-          detail
-        };
-      case 409:
-        return {
-          type: "conflict",
-          status,
-          message: "Conflict",
-          recovery: "The resource changed or already exists; re-fetch current state and retry.",
-          retryable: false,
-          detail
-        };
-      case 429: {
-        const wait = retryAfterSeconds(err);
-        return {
-          type: "rate_limited",
-          status,
-          message: `${opts.service} is rate limiting these requests`,
-          recovery: wait === void 0 ? `${opts.service} did not say how long to wait. Pause a few seconds before retrying, and make fewer requests at once.` : `${opts.service} asked for a ${wait}s pause before the next request. Wait at least that long, then retry.`,
-          retryable: true,
-          ...wait === void 0 ? {} : { detail: { retryAfterSeconds: wait } }
-        };
-      }
-    }
-    if (status >= 500) {
-      return {
-        type: "server",
-        status,
-        message: status === 503 ? `${opts.service} returned 503 (service unavailable)` : `${opts.service} returned ${status}`,
-        recovery: status === 503 ? `${opts.service} is temporarily refusing work. Retry shortly.` : `${opts.service} failed to complete the request. Usually temporary, so retry. If it persists, the request itself may be at fault.`,
-        retryable: true,
-        detail
-      };
-    }
-    return {
-      type: "unknown",
-      status,
-      message: `${opts.service} error (HTTP ${status}): ${message}`,
-      recovery: "Inspect the detail field for the API response.",
-      retryable: false,
-      detail
-    };
-  }
-  const code = errorCode(err);
-  const transport = classifyTransport(err, code, message, opts);
-  if (transport)
-    return transport;
-  return { type: "unknown", message, recovery: "Unexpected error; inspect the message.", retryable: false };
-}
-function classifyTransport(err, code, message, opts) {
-  const matches = (codes) => code !== void 0 && codes.includes(code) || codes.some((c) => message.includes(c));
-  const host = targetHost(err);
-  const where = host ?? opts.service;
-  const urlVar = opts.urlEnvVar ?? "the base-URL environment variable";
-  if (matches(TRANSPORT_CODES.readTimeout)) {
-    const limit = configuredTimeoutMs(err);
-    return {
-      type: "timeout",
-      message: `${opts.service} did not respond${limit === void 0 ? " in time" : ` within ${humanMs(limit)}`}`,
-      recovery: `The request reached ${opts.service} but no response came back in time. Usually the server is busy or the query is too large. Retry, or ask for less: fewer results per page, fewer fields, a narrower query.`,
-      retryable: true
-    };
-  }
-  if (matches(TRANSPORT_CODES.connectTimeout)) {
-    const limit = configuredTimeoutMs(err);
-    return {
-      type: "timeout",
-      message: `Could not open a connection to ${where}${limit === void 0 ? "" : ` within ${humanMs(limit)}`}`,
-      recovery: `The host did not accept a connection in time. If it is reachable at all it is likely overloaded, so retry. If this repeats, confirm ${urlVar} points at a host this machine can reach.`,
-      retryable: true
-    };
-  }
-  if (matches(TRANSPORT_CODES.unresolved)) {
-    return {
-      type: "network",
-      message: `The host ${where} does not resolve`,
-      recovery: `${urlVar} points at a hostname that cannot be looked up from this machine. Check it for a typo. Retrying will not help until it changes.`,
-      retryable: false
-    };
-  }
-  if (matches(TRANSPORT_CODES.refused)) {
-    return {
-      type: "network",
-      message: `Nothing accepted a connection at ${where}`,
-      recovery: `The host resolved but refused the connection, usually a wrong port or a service that is not running. Retrying will not help until that changes.`,
-      retryable: false
-    };
-  }
-  if (matches(TRANSPORT_CODES.dropped)) {
-    return {
-      type: "network",
-      message: `The connection to ${opts.service} closed before a response arrived`,
-      recovery: `The connection dropped mid-request. This is usually a blip, so retry.`,
-      retryable: true
-    };
-  }
-  return void 0;
-}
-function classifyError(err, opts) {
-  const base = normalize(err, opts);
-  const n = opts.adapt ? opts.adapt(base, err) : base;
-  if (n.type === "auth" && n.detail === void 0 && opts.credentialInfo) {
-    n.detail = opts.credentialInfo();
-  }
-  return {
-    envelope: {
-      error: {
-        type: n.type,
-        message: n.message,
-        recovery: n.recovery,
-        retryable: n.retryable,
-        ...n.detail !== void 0 ? { detail: n.detail } : {}
-      }
-    },
-    exitCode: TYPE_EXIT[n.type]
-  };
-}
-function createErrorHandler(opts) {
-  return (err) => {
-    const { envelope, exitCode } = classifyError(err, opts);
-    process.stderr.write(`${JSON.stringify(envelope)}
-`);
-    return process.exit(exitCode);
-  };
-}
-function isCleanCommanderExit(err) {
-  return err instanceof CommanderError && (err.exitCode === 0 || err.code === "commander.helpDisplayed" || err.code === "commander.help" || err.code === "commander.version");
-}
-function routeErrors(cmd) {
-  cmd.exitOverride();
-  cmd.configureOutput({ writeErr: () => void 0 });
-  cmd.commands.forEach(routeErrors);
-}
-function commandPath2(cmd) {
-  const parts = [];
-  let cur = cmd;
-  while (cur) {
-    parts.unshift(cur.name());
-    cur = cur.parent;
-  }
-  return parts.join(" ");
-}
-function attachSubcommandGuards(cmd) {
-  cmd.commands.forEach(attachSubcommandGuards);
-  if (cmd.commands.length === 0)
-    return;
-  const hasAction = Boolean(cmd._actionHandler);
-  if (hasAction)
-    return;
-  cmd.allowExcessArguments(true);
-  cmd.action((...params) => {
-    const invoked = params[params.length - 1];
-    const names = cmd.commands.map((c) => c.name()).filter((name) => name !== "help");
-    const [token] = invoked.args;
-    if (token === void 0)
-      throw new SubcommandRequiredError(commandPath2(cmd), names);
-    throw new UnknownSubcommandError(commandPath2(cmd), token, names, suggestSubcommand(token, names));
-  });
-}
-function editDistance(a, b) {
-  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i++) {
-    const row = [i];
-    for (let j = 1; j <= b.length; j++) {
-      const substitution = prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
-      row[j] = Math.min(row[j - 1] + 1, prev[j] + 1, substitution);
-    }
-    prev = row;
-  }
-  return prev[b.length];
-}
-function suggestSubcommand(token, names) {
-  const MAX_EDITS = 2;
-  let best;
-  for (const name of names) {
-    const distance = editDistance(token.toLowerCase(), name.toLowerCase());
-    if (distance <= MAX_EDITS && distance < token.length && (!best || distance < best.distance)) {
-      best = { name, distance };
-    }
-  }
-  return best?.name;
-}
-async function runCli(program, opts) {
-  routeErrors(program);
-  attachSubcommandGuards(program);
-  try {
-    await program.parseAsync();
-  } catch (err) {
-    if (isCleanCommanderExit(err)) {
-      process.exit(err.exitCode ?? 0);
-    }
-    createErrorHandler(opts)(err);
-  }
-}
+import {
+  CliAuthError,
+  CliNotFoundError,
+  CliUsageError,
+  bodyOption,
+  cacheGetOrFetch,
+  commentOption,
+  date,
+  dateTime,
+  examples,
+  intInRange,
+  integer,
+  jsonShape,
+  listOf,
+  nonEmpty,
+  nonNegativeInt,
+  paginationOptions,
+  positiveInt,
+  readPackageVersion,
+  resolveTextOrFile,
+  runCli,
+  scopeIdOption,
+  subEntityOption,
+  subjectArg,
+  text,
+  textOrFileOption
+} from "./chunk-3GFKV36K.js";
 
 // src/program.ts
 import { styleText } from "util";
@@ -1294,10 +637,10 @@ function issues(parent) {
 }
 
 // src/commands/board/list.ts
-import { Option as Option2 } from "commander";
+import { Option } from "commander";
 var BOARD_TYPES = ["scrum", "kanban", "simple"];
 function list(parent) {
-  const cmd = parent.command("list").description("List agile boards").option("--limit <number>", "Max results (1-1000)", intInRange(1, 1e3), 25).option("--project <key>", "Filter boards by project key or ID", text).addOption(new Option2("--type <type>", "Board type filter").choices(BOARD_TYPES)).option("--name <name>", "Filter boards by name", text);
+  const cmd = parent.command("list").description("List agile boards").option("--limit <number>", "Max results (1-1000)", intInRange(1, 1e3), 25).option("--project <key>", "Filter boards by project key or ID", text).addOption(new Option("--type <type>", "Board type filter").choices(BOARD_TYPES)).option("--name <name>", "Filter boards by name", text);
   examples(cmd, ["", "--limit 10", "--project PROJ", '--type scrum --name "Team Board"']);
   cmd.action(async (opts) => {
     const client = getClient();
@@ -1321,7 +664,7 @@ function registerBoardCommands(program) {
 }
 
 // src/commands/component/create.ts
-import { Option as Option3 } from "commander";
+import { Option as Option2 } from "commander";
 var ASSIGNEE_TYPES = [
   "PROJECT_DEFAULT",
   "COMPONENT_LEAD",
@@ -1329,7 +672,7 @@ var ASSIGNEE_TYPES = [
   "UNASSIGNED"
 ];
 function create(parent) {
-  const cmd = parent.command("create").description("Create a new component in a project").requiredOption("--project <key>", "Project key (e.g., PROJ)", text).requiredOption("--name <name>", "Component name", text).option("--lead <username>", "Username of the component lead", text).addOption(new Option3("--assignee-type <type>", "Assignee strategy").choices(ASSIGNEE_TYPES));
+  const cmd = parent.command("create").description("Create a new component in a project").requiredOption("--project <key>", "Project key (e.g., PROJ)", text).requiredOption("--name <name>", "Component name", text).option("--lead <username>", "Username of the component lead", text).addOption(new Option2("--assignee-type <type>", "Assignee strategy").choices(ASSIGNEE_TYPES));
   textOrFileOption(cmd, "description", { description: "Component description" });
   examples(cmd, [
     "--project PROJ --name Backend",
@@ -1397,7 +740,7 @@ function list2(parent) {
 }
 
 // src/commands/component/update.ts
-import { Option as Option4 } from "commander";
+import { Option as Option3 } from "commander";
 var ASSIGNEE_TYPES2 = [
   "PROJECT_DEFAULT",
   "COMPONENT_LEAD",
@@ -1405,7 +748,7 @@ var ASSIGNEE_TYPES2 = [
   "UNASSIGNED"
 ];
 function update(parent) {
-  const cmd = parent.command("update").description("Update an existing component (only provided fields are changed)").argument("<id>", "Component ID", positiveInt).option("--name <name>", "New component name", text).option("--lead <username>", "Username of the component lead (empty string clears it)", text).addOption(new Option4("--assignee-type <type>", "New assignee strategy").choices(ASSIGNEE_TYPES2));
+  const cmd = parent.command("update").description("Update an existing component (only provided fields are changed)").argument("<id>", "Component ID", positiveInt).option("--name <name>", "New component name", text).option("--lead <username>", "Username of the component lead (empty string clears it)", text).addOption(new Option3("--assignee-type <type>", "New assignee strategy").choices(ASSIGNEE_TYPES2));
   textOrFileOption(cmd, "description", { description: "New component description" });
   examples(cmd, [
     "11289 --name Backend",
@@ -1502,21 +845,21 @@ async function resolveUserToken(token) {
 
 // src/utils/validators.ts
 import { existsSync } from "fs";
-import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { InvalidArgumentError } from "commander";
 function issueKey(raw) {
   if (!/^(\d+|[A-Z][A-Z0-9]+-\d+)$/.test(raw)) {
-    throw new InvalidArgumentError4("Must be a Jira issue key (e.g. PROJ-123) or a numeric issue id.");
+    throw new InvalidArgumentError("Must be a Jira issue key (e.g. PROJ-123) or a numeric issue id.");
   }
   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.");
+  if (keys.length === 0) throw new InvalidArgumentError("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}`);
+  if (!existsSync(raw)) throw new InvalidArgumentError(`File not found: ${raw}`);
   return raw;
 }
 
@@ -1548,14 +891,14 @@ function deleteAttachment(parent) {
 }
 
 // src/commands/issue/attachment/download-all.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
+import { mkdirSync } from "fs";
+import { join } from "path";
 function downloadAll(parent) {
   const cmd = parent.command("download-all").description("Download all attachments from an issue").argument("<key>", "Issue key", issueKey).requiredOption("--output <dir>", "Local directory to save attachments into", text);
   examples(cmd, ["PROJ-123 --output ./downloads"]);
   cmd.action(async (key, opts) => {
     const client = getClient();
-    mkdirSync2(opts.output, { recursive: true });
+    mkdirSync(opts.output, { recursive: true });
     const issue = await client.issues.get({
       issueKeyOrId: key,
       fields: ["attachment"]
@@ -1572,7 +915,7 @@ function downloadAll(parent) {
         failed.push({ filename: att.filename, error: "No content URL" });
         continue;
       }
-      const destPath = join3(opts.output, att.filename);
+      const destPath = join(opts.output, att.filename);
       try {
         await client.issues.downloadAttachment({ url: att.content, destinationPath: destPath });
         results.push({ filename: att.filename, size: att.size, path: destPath });
@@ -1743,7 +1086,7 @@ function changelog(parent) {
 // src/commands/issue/clone.ts
 import { unlink } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { join as join2 } from "path";
 var CLONE_FIELDS = [
   "summary",
   "description",
@@ -1793,7 +1136,7 @@ function clone(parent) {
         const tmpFiles = [];
         const copied = await Promise.all(
           f.attachment.map(async (att) => {
-            const tmpPath = join4(tmpdir(), `jiradc-clone-${Date.now()}-${att.filename}`);
+            const tmpPath = join2(tmpdir(), `jiradc-clone-${Date.now()}-${att.filename}`);
             tmpFiles.push(tmpPath);
             await client.issues.downloadAttachment({ url: att.content, destinationPath: tmpPath });
             await client.issues.addAttachment({ issueKeyOrId: newKey, filePath: tmpPath });
@@ -1926,7 +1269,7 @@ function registerCommentCommands(parent) {
 }
 
 // src/commands/issue/create.ts
-import { Option as Option5 } from "commander";
+import { Option as Option4 } from "commander";
 import { z as z2 } from "zod";
 var fieldsSchema = z2.record(z2.unknown());
 function create3(parent) {
@@ -1935,7 +1278,7 @@ function create3(parent) {
     `Additional fields as JSON (e.g., '{"customfield_10100": "EPIC-1"}')`,
     jsonShape(fieldsSchema)
   ).addOption(
-    new Option5("--custom-fields <json>", "Deprecated alias for --fields").argParser(jsonShape(fieldsSchema)).hideHelp()
+    new Option4("--custom-fields <json>", "Deprecated alias for --fields").argParser(jsonShape(fieldsSchema)).hideHelp()
   );
   textOrFileOption(cmd, "description", { description: "Issue description in wiki markup" });
   examples(cmd, [
@@ -2459,20 +1802,20 @@ function unlink2(parent) {
 import { z as z4 } from "zod";
 
 // src/utils/multi-value.ts
-import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
 function parseMultiValue(flagName, raw) {
   const items = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
   if (items.length === 0) {
-    throw new InvalidArgumentError5(`${flagName} cannot be empty`);
+    throw new InvalidArgumentError2(`${flagName} cannot be empty`);
   }
   const lonePrefix = items.find((s) => s === "+" || s === "-");
   if (lonePrefix !== void 0) {
-    throw new InvalidArgumentError5(`${flagName} has an empty value after '${lonePrefix}' prefix`);
+    throw new InvalidArgumentError2(`${flagName} has an empty value after '${lonePrefix}' prefix`);
   }
   const prefixed = items.filter((s) => s.startsWith("+") || s.startsWith("-"));
   const bare = items.filter((s) => !s.startsWith("+") && !s.startsWith("-"));
   if (prefixed.length > 0 && bare.length > 0) {
-    throw new InvalidArgumentError5(
+    throw new InvalidArgumentError2(
       `${flagName} mixes set and mutate syntax. Either all values have +/- prefix, or none do.`
     );
   }
@@ -2601,12 +1944,12 @@ function create4(parent) {
 }
 
 // src/commands/issue/worklog/delete.ts
-import { Option as Option6 } from "commander";
+import { Option as Option5 } from "commander";
 var ADJUST_ESTIMATE = ["new", "leave", "manual", "auto"];
 function deleteWorklog(parent) {
   const cmd = parent.command("delete").description("Delete a worklog entry").argument("<key>", "Issue key", issueKey);
   subEntityOption(cmd, "worklog", { mandatory: true });
-  cmd.addOption(new Option6("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text).option(
+  cmd.addOption(new Option5("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text).option(
     "--increase-by <amount>",
     'Amount to increase the estimate by; required when --adjust-estimate is "manual"',
     text
@@ -2647,12 +1990,12 @@ function list5(parent) {
 }
 
 // src/commands/issue/worklog/update.ts
-import { Option as Option7 } from "commander";
+import { Option as Option6 } from "commander";
 var ADJUST_ESTIMATE2 = ["new", "leave", "auto"];
 function update4(parent) {
   const cmd = parent.command("update").description("Update an existing worklog entry").argument("<key>", "Issue key", issueKey);
   subEntityOption(cmd, "worklog", { mandatory: true });
-  cmd.option("--time <timeSpent>", "Time spent (e.g., '2h', '30m', '1d 4h')", text).option("--started <datetime>", "Start time in ISO 8601 format", dateTime).addOption(new Option7("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE2)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text);
+  cmd.option("--time <timeSpent>", "Time spent (e.g., '2h', '30m', '1d 4h')", text).option("--started <datetime>", "Start time in ISO 8601 format", dateTime).addOption(new Option6("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE2)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text);
   commentOption(cmd, { description: "Worklog comment" });
   examples(cmd, [
     'PROJ-123 --worklog-id 12345 --time "1h 30m"',
@@ -2836,10 +2179,10 @@ function issues2(parent) {
 }
 
 // src/commands/sprint/list.ts
-import { Option as Option8 } from "commander";
+import { Option as Option7 } from "commander";
 var SPRINT_STATES = ["future", "active", "closed"];
 function list7(parent) {
-  const cmd = parent.command("list").description("List sprints for a board").requiredOption("--board <id>", "Board ID", positiveInt).addOption(new Option8("--state <state>", "Filter by sprint state").choices(SPRINT_STATES));
+  const cmd = parent.command("list").description("List sprints for a board").requiredOption("--board <id>", "Board ID", positiveInt).addOption(new Option7("--state <state>", "Filter by sprint state").choices(SPRINT_STATES));
   examples(cmd, ["--board 42", "--board 42 --state active"]);
   cmd.action(async (opts) => {
     const client = getClient();
@@ -2852,10 +2195,10 @@ function list7(parent) {
 }
 
 // src/commands/sprint/update.ts
-import { Argument as Argument4, Option as Option9 } from "commander";
+import { Argument as Argument4, Option as Option8 } from "commander";
 var SPRINT_STATES2 = ["future", "active", "closed"];
 function update5(parent) {
-  const cmd = parent.command("update").description("Update an existing sprint").addArgument(new Argument4("<id>", "Sprint ID").argParser(positiveInt)).option("--name <name>", "New sprint name", text).addOption(new Option9("--state <state>", "New sprint state").choices(SPRINT_STATES2)).option("--start-date <date>", "New start date in ISO 8601 format", text).option("--end-date <date>", "New end date in ISO 8601 format", text).option("--goal <goal>", "New sprint goal", text);
+  const cmd = parent.command("update").description("Update an existing sprint").addArgument(new Argument4("<id>", "Sprint ID").argParser(positiveInt)).option("--name <name>", "New sprint name", text).addOption(new Option8("--state <state>", "New sprint state").choices(SPRINT_STATES2)).option("--start-date <date>", "New start date in ISO 8601 format", text).option("--end-date <date>", "New end date in ISO 8601 format", text).option("--goal <goal>", "New sprint goal", text);
   examples(cmd, [
     '100 --name "Sprint 10 - Extended"',
     "100 --state active",
@@ -2895,6 +2238,484 @@ function registerSprintCommands(program) {
   deleteSprint(sprint);
 }
 
+// src/commands/structure/create.ts
+function create6(parent) {
+  const cmd = parent.command("create").description("Create a new, empty structure").requiredOption("--name <text>", "Structure name", text).option("--description <text>", "Structure description", text);
+  examples(cmd, ['--name "Release 24.3"', '--name Scratch --description "Throwaway"']);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    output(await client.structure.create({ name: opts.name, description: opts.description }));
+  });
+}
+
+// src/commands/structure/delete.ts
+function deleteStructure(parent) {
+  const cmd = parent.command("delete").description("Delete a structure and every row in it. The rows go; the underlying Jira issues do not.");
+  subjectArg(cmd, "structureId", { description: "Structure id", parser: positiveInt });
+  examples(cmd, ["119"]);
+  cmd.action(async (structureId) => {
+    const client = getClient();
+    await client.structure.delete({ structureId });
+    output({ deleted: true, structureId });
+  });
+}
+
+// src/utils/structure/forest.ts
+var FOLDER_TYPE_KEY = "com.almworks.jira.structure:type-folder";
+function parseForest(forest) {
+  const formula = forest.formula ?? "";
+  if (formula.trim() === "") return [];
+  const rows = [];
+  const lastRowAtDepth = /* @__PURE__ */ new Map();
+  for (const component of formula.split(",")) {
+    const parts = component.split(":");
+    if (parts.length < 3) {
+      throw new CliUsageError(`Malformed forest component "${component}": expected rowId:depth:itemId`);
+    }
+    const [rawRowId, rawDepth, rawItemId] = parts;
+    const rowId = Number(rawRowId);
+    const depth = Number(rawDepth);
+    if (!Number.isInteger(rowId) || !Number.isInteger(depth) || depth < 0) {
+      throw new CliUsageError(`Malformed forest component "${component}": rowId and depth must be integers`);
+    }
+    const slash = rawItemId.indexOf("/");
+    const prefix = slash === -1 ? void 0 : rawItemId.slice(0, slash);
+    const numeric = Number(slash === -1 ? rawItemId : rawItemId.slice(slash + 1));
+    if (!Number.isInteger(numeric)) {
+      throw new CliUsageError(`Malformed forest component "${component}": item id is not numeric`);
+    }
+    const itemType = prefix === void 0 ? "issue" : forest.itemTypes?.[prefix] ?? `unknown:${prefix}`;
+    rows.push({
+      rowId,
+      depth,
+      itemId: rawItemId,
+      itemType,
+      itemNumericId: numeric,
+      parentRowId: depth === 0 ? 0 : lastRowAtDepth.get(depth - 1) ?? 0,
+      isFolder: itemType === FOLDER_TYPE_KEY
+    });
+    lastRowAtDepth.set(depth, rowId);
+    for (const seen of [...lastRowAtDepth.keys()]) {
+      if (seen > depth) lastRowAtDepth.delete(seen);
+    }
+  }
+  return rows;
+}
+function childrenOf(rows, parentRowId) {
+  return rows.filter((r) => r.parentRowId === parentRowId);
+}
+function descendantsOf(rows, parentRowId) {
+  const start = rows.findIndex((r) => r.rowId === parentRowId);
+  if (start === -1) return [];
+  const parentDepth = rows[start].depth;
+  const out = [];
+  for (let i = start + 1; i < rows.length && rows[i].depth > parentDepth; i += 1) out.push(rows[i]);
+  return out;
+}
+function withinDepth(rows, parentRowId, maxDepth) {
+  const base = parentRowId === 0 ? -1 : rows.find((r) => r.rowId === parentRowId)?.depth ?? -1;
+  const scope = parentRowId === 0 ? rows : descendantsOf(rows, parentRowId);
+  return scope.filter((r) => r.depth - base <= maxDepth);
+}
+function addSpec(itemId, placeholderRowId = -100) {
+  if (placeholderRowId >= 0) {
+    throw new CliUsageError(`Placeholder row id must be negative, got ${placeholderRowId}`);
+  }
+  return `${placeholderRowId}:0:${itemId}`;
+}
+function assertRowExists(rows, rowId, structureId, what = "Row") {
+  if (!rows.some((r) => r.rowId === rowId)) {
+    throw new CliNotFoundError(`${what} ${rowId} is not in structure ${structureId}`);
+  }
+}
+
+// src/utils/structure/resolve.ts
+var VALUE_BATCH_SIZE = 500;
+async function resolveStructureId(client, idOrName) {
+  if (/^\d+$/.test(idOrName)) return Number(idOrName);
+  const { structures } = await client.structure.list();
+  const wanted = idOrName.trim().toLowerCase();
+  const matches = structures.filter((s) => s.name?.trim().toLowerCase() === wanted);
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length === 0) {
+    throw new CliUsageError(
+      `No structure named "${idOrName}"`,
+      "Pass a structure id, or one of the names in detail.available.",
+      { available: structures.map((s) => ({ id: s.id, name: s.name })).slice(0, 50) }
+    );
+  }
+  throw new CliUsageError(
+    `"${idOrName}" matches ${matches.length} structures`,
+    "Names are not unique here; pass the numeric id of the one you meant.",
+    { matches: matches.map((s) => ({ id: s.id, name: s.name })) }
+  );
+}
+async function resolveRowNames(client, structureId, rowIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (rowIds.length === 0) return out;
+  for (let i = 0; i < rowIds.length; i += VALUE_BATCH_SIZE) {
+    const batch = rowIds.slice(i, i + VALUE_BATCH_SIZE);
+    const res = await client.structure.getValues({
+      requests: [
+        {
+          forestSpec: { structureId },
+          rows: batch,
+          // `format` is required; without it the API returns an empty `data` array.
+          attributes: [
+            { id: "summary", format: "text" },
+            { id: "key", format: "text" }
+          ]
+        }
+      ]
+    });
+    const data = res.responses?.[0]?.data ?? [];
+    const summaries = data.find((d) => d.attribute.id === "summary")?.values ?? [];
+    const keys = data.find((d) => d.attribute.id === "key")?.values ?? [];
+    batch.forEach((rowId, idx) => {
+      out.set(rowId, { name: summaries[idx] ?? null, key: keys[idx] ?? null });
+    });
+  }
+  return out;
+}
+async function withNames(client, structureId, rows) {
+  const names = await resolveRowNames(
+    client,
+    structureId,
+    rows.map((r) => r.rowId)
+  );
+  return rows.map((r) => ({
+    rowId: r.rowId,
+    depth: r.depth,
+    parentRowId: r.parentRowId,
+    type: r.isFolder ? "folder" : r.itemType === "issue" ? "issue" : r.itemType,
+    name: names.get(r.rowId)?.name ?? null,
+    key: names.get(r.rowId)?.key ?? null,
+    itemId: r.itemId
+  }));
+}
+
+// src/commands/structure/folder/create.ts
+function create7(parent) {
+  const cmd = parent.command("create").description("Create a folder in a structure");
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  cmd.requiredOption("--name <text>", "Folder name", text);
+  cmd.option("--under <rowId>", "Parent folder row id (0 = top level)", integer, 0);
+  examples(cmd, ["--structure 42 --name Backlog", '--structure 42 --name "Phase Two" --under 1001']);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const structureId = await resolveStructureId(client, opts.structure);
+    const forest = await client.structure.getForest({ structureId });
+    if (opts.under !== 0) {
+      assertRowExists(parseForest(forest), opts.under, structureId, "Target parent row");
+    }
+    const result = await client.structure.createFolder({
+      structureId,
+      version: forest.version,
+      name: opts.name,
+      under: opts.under
+    });
+    output({
+      structureId,
+      itemId: result.itemId,
+      rowId: result.newRowIds?.[0] ?? null,
+      name: opts.name,
+      under: opts.under
+    });
+  });
+}
+
+// src/commands/structure/folder/get.ts
+function get7(parent) {
+  const cmd = parent.command("get").description("Get one folder row, with its path and child counts");
+  subjectArg(cmd, "rowId", { description: "Folder row id", parser: positiveInt });
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  examples(cmd, ['1001 --structure "My Structure"', "1001 --structure 42"]);
+  cmd.action(async (rowId, opts) => {
+    const client = getClient();
+    const structureId = await resolveStructureId(client, opts.structure);
+    const rows = parseForest(await client.structure.getForest({ structureId }));
+    const row = rows.find((r) => r.rowId === rowId);
+    if (!row) throw new CliNotFoundError(`Row ${rowId} is not in structure ${structureId}`);
+    const ancestry = [];
+    for (let cur = row; cur.parentRowId !== 0; ) {
+      const next = rows.find((r) => r.rowId === cur.parentRowId);
+      if (!next) break;
+      ancestry.unshift(next);
+      cur = next;
+    }
+    const children = childrenOf(rows, rowId);
+    const [self, ...path] = await withNames(client, structureId, [row, ...ancestry]);
+    output({
+      structureId,
+      ...self,
+      path: path.map((p) => p.name),
+      childCount: children.length,
+      childFolderCount: children.filter((c) => c.isFolder).length,
+      descendantCount: descendantsOf(rows, rowId).length
+    });
+  });
+}
+
+// src/commands/structure/folder/list.ts
+function list8(parent) {
+  const cmd = parent.command("list").description("List folders in a structure");
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  cmd.option("--parent <rowId>", "Only look under this folder row (default: top level)", integer, 0);
+  cmd.option("--depth <n>", "How many levels below the parent to include", integer, 1);
+  cmd.option("--query <text>", "Only folders whose name contains this text, at any depth", text);
+  paginationOptions(cmd, { defaultLimit: 25 });
+  cmd.option("--all", "Collect every match, not just one page");
+  examples(cmd, [
+    '--structure "My Structure"',
+    '--structure "My Structure" --query billing',
+    "--structure 42 --parent 1001 --depth 2"
+  ]);
+  cmd.action(
+    async (opts) => {
+      const client = getClient();
+      const structureId = await resolveStructureId(client, opts.structure);
+      const forest = await client.structure.getForest({ structureId });
+      const rows = parseForest(forest);
+      const scoped = opts.query ? opts.parent === 0 ? rows : descendantsOf(rows, opts.parent) : withinDepth(rows, opts.parent, opts.depth);
+      const folders = scoped.filter((r) => r.isFolder);
+      let named = await withNames(client, structureId, folders);
+      if (opts.query) {
+        const needle = opts.query.toLowerCase();
+        named = named.filter((r) => (r.name ?? "").toLowerCase().includes(needle));
+      }
+      const start = opts.start ?? 0;
+      const page = opts.all ? named.slice(start) : named.slice(start, start + opts.limit);
+      output({ structureId, total: named.length, start, count: page.length, folders: page });
+    }
+  );
+}
+
+// src/commands/structure/folder/index.ts
+function registerFolderCommands(structure) {
+  const folder = structure.command("folder").description("Find and create folders inside a structure");
+  examples(folder, ['list --structure "My Structure" --query billing']);
+  list8(folder);
+  get7(folder);
+  create7(folder);
+}
+
+// src/commands/structure/get.ts
+function get8(parent) {
+  const cmd = parent.command("get").description("Get one structure by id");
+  subjectArg(cmd, "structureId", { description: "Structure id", parser: positiveInt });
+  cmd.option("--permissions", "Include the structure\u2019s permission rules");
+  examples(cmd, ["1", "1 --permissions"]);
+  cmd.action(async (structureId, opts) => {
+    const client = getClient();
+    output(await client.structure.get({ structureId, withPermissions: opts.permissions }));
+  });
+}
+
+// src/commands/structure/list.ts
+function list9(parent) {
+  const cmd = parent.command("list").description("List every structure visible to you");
+  cmd.option("--permissions", "Include each structure\u2019s permission rules");
+  paginationOptions(cmd, { defaultLimit: 25 });
+  cmd.option("--all", "Collect every match, not just one page");
+  examples(cmd, ["", "--limit 50", "--all --permissions"]);
+  cmd.action(async (opts) => {
+    if (opts.all && process.argv.includes("--limit")) {
+      const { CliUsageError: CliUsageError2 } = await import("./dist-JXPWCMQP.js");
+      throw new CliUsageError2("--all and --limit ask for opposite things; pass one or the other");
+    }
+    const client = getClient();
+    const { structures } = await client.structure.list({ withPermissions: opts.permissions });
+    const start = opts.start ?? 0;
+    const page = opts.all ? structures.slice(start) : structures.slice(start, start + opts.limit);
+    output({ total: structures.length, start, count: page.length, structures: page });
+  });
+}
+
+// src/commands/structure/row/add.ts
+function add(parent) {
+  const cmd = parent.command("add").description("Add an issue to a structure, under a folder");
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  cmd.requiredOption("--issue <key>", "Issue key to place, e.g. PROJ-123", text);
+  cmd.option("--under <rowId>", "Parent folder row id (0 = top level)", integer, 0);
+  examples(cmd, ["--structure 42 --issue PROJ-123 --under 1001", '--structure "My Structure" --issue PROJ-123']);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const structureId = await resolveStructureId(client, opts.structure);
+    const issue = await client.issues.get({ issueKeyOrId: opts.issue, fields: ["summary"] });
+    const issueId = Number(issue.id);
+    const forest = await client.structure.getForest({ structureId });
+    const rows = parseForest(forest);
+    if (opts.under !== 0) assertRowExists(rows, opts.under, structureId, "Target parent row");
+    const already = childrenOf(rows, opts.under).find((r) => r.itemType === "issue" && r.itemNumericId === issueId);
+    const elsewhere = rows.filter((r) => r.itemType === "issue" && r.itemNumericId === issueId && r.parentRowId !== opts.under).map((r) => ({ rowId: r.rowId, parentRowId: r.parentRowId }));
+    if (already) {
+      output({
+        structureId,
+        issue: issue.key,
+        rowId: already.rowId,
+        under: opts.under,
+        added: false,
+        reason: "already under this parent",
+        alsoAppearsAt: elsewhere
+      });
+      return;
+    }
+    const result = await client.structure.updateForest({
+      structureId,
+      version: forest.version,
+      actions: [{ action: "add", under: opts.under, after: 0, before: 0, forest: addSpec(issueId) }]
+    });
+    output({
+      structureId,
+      issue: issue.key,
+      rowId: result.newRowIds?.[0] ?? null,
+      under: opts.under,
+      added: true,
+      alsoAppearsAt: elsewhere
+    });
+  });
+}
+
+// src/commands/structure/row/list.ts
+function list10(parent) {
+  const cmd = parent.command("list").description("List rows (issues and folders) under a parent row");
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  cmd.option("--parent <rowId>", "Parent row id (0 = top level)", integer, 0);
+  cmd.option("--depth <n>", "How many levels below the parent to include", integer, 1);
+  paginationOptions(cmd, { defaultLimit: 25 });
+  cmd.option("--all", "Collect every match, not just one page");
+  examples(cmd, ["--structure 42", '--structure "My Structure" --parent 1001 --depth 2']);
+  cmd.action(
+    async (opts) => {
+      const client = getClient();
+      const structureId = await resolveStructureId(client, opts.structure);
+      const rows = parseForest(await client.structure.getForest({ structureId }));
+      const scoped = withinDepth(rows, opts.parent, opts.depth);
+      const start = opts.start ?? 0;
+      const page = opts.all ? scoped.slice(start) : scoped.slice(start, start + opts.limit);
+      output({
+        structureId,
+        total: scoped.length,
+        start,
+        count: page.length,
+        rows: await withNames(client, structureId, page)
+      });
+    }
+  );
+}
+
+// src/commands/structure/row/move.ts
+function move(parent) {
+  const cmd = parent.command("move").description("Move a row to a different parent");
+  subjectArg(cmd, "rowId", { description: "Row id to move (not the issue id)", parser: positiveInt });
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  cmd.requiredOption("--under <rowId>", "New parent row id (0 = top level)", integer);
+  examples(cmd, ["1002 --structure 42 --under 1001", '1002 --structure "My Structure" --under 0']);
+  cmd.action(async (rowId, opts) => {
+    const client = getClient();
+    const structureId = await resolveStructureId(client, opts.structure);
+    const forest = await client.structure.getForest({ structureId });
+    const rows = parseForest(forest);
+    assertRowExists(rows, rowId, structureId);
+    if (opts.under !== 0) assertRowExists(rows, opts.under, structureId, "Target parent row");
+    const row = rows.find((r) => r.rowId === rowId);
+    const result = await client.structure.updateForest({
+      structureId,
+      version: forest.version,
+      actions: [{ action: "move", rowId, under: opts.under, after: 0, before: 0 }]
+    });
+    output({ structureId, rowId, from: row.parentRowId, under: opts.under, moved: result.successfulActions > 0 });
+  });
+}
+
+// src/commands/structure/row/remove.ts
+function remove(parent) {
+  const cmd = parent.command("remove").description("Remove a row from a structure. The row goes; the underlying Jira issue does not.");
+  subjectArg(cmd, "rowId", { description: "Row id to remove (not the issue id)", parser: positiveInt });
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  examples(cmd, ["1002 --structure 42", '1002 --structure "My Structure"']);
+  cmd.action(async (rowId, opts) => {
+    const client = getClient();
+    const structureId = await resolveStructureId(client, opts.structure);
+    const forest = await client.structure.getForest({ structureId });
+    const rows = parseForest(forest);
+    assertRowExists(rows, rowId, structureId);
+    const removedDescendants = descendantsOf(rows, rowId).length;
+    const result = await client.structure.updateForest({
+      structureId,
+      version: forest.version,
+      actions: [{ action: "remove", rowId }]
+    });
+    output({ structureId, rowId, removed: result.successfulActions > 0, removedDescendants });
+  });
+}
+
+// src/commands/structure/row/index.ts
+function registerRowCommands(structure) {
+  const row = structure.command("row").description("Place, move and remove rows in a structure. A row is one appearance of an issue, not the issue.");
+  examples(row, ["add --structure 42 --issue PROJ-123 --under 1001"]);
+  list10(row);
+  add(row);
+  move(row);
+  remove(row);
+}
+
+// src/commands/structure/search.ts
+function search3(parent) {
+  const cmd = parent.command("search").description("Find issues by their place in a structure, using S-JQL");
+  subjectArg(cmd, "sjql", {
+    description: `S-JQL query, e.g. "child of folder('Billing')"`,
+    parser: nonEmpty
+  });
+  scopeIdOption(cmd, "structure", { mandatory: true });
+  cmd.option("--fields <fields>", "Comma-separated fields to return", text);
+  paginationOptions(cmd, { defaultLimit: 25, maxLimit: 50 });
+  examples(cmd, [
+    `"child of folder('Billing')" --structure "My Structure"`,
+    `"descendants of folder('Billing')" --structure 42 --limit 50`
+  ]);
+  cmd.action(async (sjql, opts) => {
+    for (const [name, value] of [
+      ["--structure", opts.structure],
+      ["<sjql>", sjql]
+    ]) {
+      if (value.includes('"')) {
+        throw new CliUsageError(
+          `${name} must not contain a double quote \u2014 S-JQL uses single quotes inside, e.g. "child of folder('Billing')"`
+        );
+      }
+    }
+    const client = getClient();
+    const jql = `issue in structure("${opts.structure}", "${sjql}")`;
+    const res = await client.issues.search({
+      jql,
+      startAt: opts.start ?? 0,
+      maxResults: opts.limit,
+      fields: opts.fields
+    });
+    output({
+      jql,
+      total: res.total,
+      startAt: res.startAt,
+      count: res.issues?.length ?? 0,
+      issues: (res.issues ?? []).map(transformIssue)
+    });
+  });
+}
+
+// src/commands/structure/index.ts
+function registerStructureCommands(program) {
+  const structure = program.command("structure").description("Structure plugin \u2014 browse and edit the hierarchies issues are filed into");
+  examples(structure, ["list", `search "child of folder('Billing')" --structure "My Structure"`]);
+  list9(structure);
+  get8(structure);
+  create6(structure);
+  deleteStructure(structure);
+  search3(structure);
+  registerFolderCommands(structure);
+  registerRowCommands(structure);
+}
+
 // src/commands/token/client.ts
 import { JiraClient as JiraClient2 } from "jira-data-center-client";
 function getTokenClient(options = {}) {
@@ -2914,7 +2735,7 @@ function getTokenClient(options = {}) {
 }
 
 // src/commands/token/create.ts
-function create6(parent) {
+function create8(parent) {
   const cmd = parent.command("create").description("Create a Personal Access Token. The secret is returned exactly once.").requiredOption("--name <name>", "Token name", text).option(
     "--expiration-duration <days>",
     "Token lifetime in days. Omit for a non-expiring token (admin policy permitting).",
@@ -2941,7 +2762,7 @@ function create6(parent) {
 }
 
 // src/commands/token/list.ts
-function list8(parent) {
+function list11(parent) {
   const cmd = parent.command("list").description("List Personal Access Tokens owned by the authenticated user (secrets not included)").option("--basic-username <u>", "Override $JIRA_BASIC_USERNAME", text).option(
     "--basic-password <p>",
     "Override $JIRA_BASIC_PASSWORD (caution: visible in process table; prefer the env var)",
@@ -2984,13 +2805,13 @@ function registerTokenCommands(program) {
     "after",
     "\nAuth:\n  Requires JIRA_BASIC_USERNAME + JIRA_BASIC_PASSWORD\n  (or --basic-username / --basic-password on any subcommand)."
   );
-  create6(token);
-  list8(token);
+  create8(token);
+  list11(token);
   revoke(token);
 }
 
 // src/commands/user/get.ts
-function get7(parent) {
+function get9(parent) {
   const cmd = parent.command("get").description("Get a user profile by exact username or key").argument("<username>", "Username or user key", nonEmpty).option("--by-key", "Treat the positional argument as a user key instead of a username");
   examples(cmd, ["jsmith", "JIRAUSER10100 --by-key"]);
   cmd.action(async (identifier, opts) => {
@@ -3012,7 +2833,7 @@ function me(parent) {
 }
 
 // src/commands/user/search.ts
-function search3(parent) {
+function search4(parent) {
   const cmd = parent.command("search").description("Search users by partial username, display name or email").argument("<query>", "Search query", nonEmpty).option("--limit <n>", "Maximum results (1-50)", intInRange(1, 50), 25).option("--start <n>", "Starting index (pagination offset)", nonNegativeInt, 0).option("--include-inactive", "Include inactive users in results", false);
   examples(cmd, ["Smith", '"John Smith"', "jsmith@example.com --limit 5"]);
   cmd.action(async (query, opts) => {
@@ -3033,8 +2854,8 @@ function registerUserCommands(program) {
   const user = program.command("user").description("User operations");
   examples(user, ["me", "get jsmith", "search Smith"]);
   me(user);
-  get7(user);
-  search3(user);
+  get9(user);
+  search4(user);
 }
 
 // src/utils/xray/guards.ts
@@ -3050,7 +2871,7 @@ function assertAtLeastOne(opts, keys) {
 }
 
 // src/commands/xray/execution/add.ts
-function add(parent) {
+function add2(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. PROJ-200)", issueKey).option("--test <keys>", "Comma-separated test issue keys to add (e.g. PROJ-1,PROJ-2)", keyList).option(
     "--set <keys>",
     "Comma-separated Test Set keys; each set's current tests are added to the execution (e.g. PROJ-300)",
@@ -3068,8 +2889,8 @@ function add(parent) {
     const keys = new Set(opts.test ?? []);
     if (opts.set) {
       const lists = await Promise.all(opts.set.map((setKey) => client.testSets.listTests({ setKey })));
-      for (const list21 of lists) {
-        const tests = Array.isArray(list21) ? list21 : list21.tests ?? [];
+      for (const list24 of lists) {
+        const tests = Array.isArray(list24) ? list24 : list24.tests ?? [];
         for (const t of tests) {
           if (t.key) keys.add(String(t.key));
         }
@@ -3115,7 +2936,7 @@ function deleteXrayIssue(client, key) {
 }
 
 // src/commands/xray/execution/create.ts
-function create7(parent) {
+function create9(parent) {
   const cmd = parent.command("create").description("Create a new Xray Test Execution issue").requiredOption("--project <key>", "Project key (e.g. PROJ)", text).requiredOption("--summary <text>", "Test Execution summary (title)", text);
   textOrFileOption(cmd, "description", { description: "Test Execution description" });
   examples(cmd, [
@@ -3147,7 +2968,7 @@ function deleteExecution(parent) {
 }
 
 // src/commands/xray/execution/list.ts
-function list9(parent) {
+function list12(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. PROJ-584)", issueKey);
@@ -3160,7 +2981,7 @@ function list9(parent) {
 }
 
 // src/commands/xray/execution/remove.ts
-function remove(parent) {
+function remove2(parent) {
   const cmd = parent.command("remove").description("Remove tests from a Test Execution").argument("<execKey>", "Test Execution issue key (e.g. PROJ-200)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["PROJ-200 --test PROJ-1", "PROJ-200 --test PROJ-1,PROJ-2"]);
   cmd.action(async (execKey, opts) => {
@@ -3193,17 +3014,17 @@ function registerExecutionCommands(xray) {
     "add PROJ-200 --test PROJ-1,PROJ-2",
     "list --test PROJ-584"
   ]);
-  create7(execution2);
+  create9(execution2);
   update6(execution2);
   deleteExecution(execution2);
-  add(execution2);
-  remove(execution2);
-  list9(execution2);
+  add2(execution2);
+  remove2(execution2);
+  list12(execution2);
 }
 
 // src/commands/xray/export/feature.ts
-import { writeFileSync as writeFileSync2 } from "fs";
-import { basename, join as join5 } from "path";
+import { writeFileSync } from "fs";
+import { basename, join as join3 } 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 PROJ-584 --output ai-584.feature"]);
@@ -3213,8 +3034,8 @@ function feature(parent) {
       keys: opts.test,
       zip: opts.zip
     });
-    const writePath = opts.output ?? join5(".", basename(filename));
-    writeFileSync2(writePath, data);
+    const writePath = opts.output ?? join3(".", basename(filename));
+    writeFileSync(writePath, data);
     output({ written: writePath, bytes: data.length });
   });
 }
@@ -3226,7 +3047,7 @@ function registerExportCommands(xray) {
 }
 
 // src/commands/xray/field/list.ts
-function list10(parent) {
+function list13(parent) {
   const cmd = parent.command("list").description("List Xray custom fields available on this instance");
   examples(cmd, [""]);
   cmd.action(async () => {
@@ -3239,11 +3060,11 @@ function list10(parent) {
 function registerFieldCommands2(xray) {
   const field = xray.command("field").description("Xray field discovery");
   examples(field, ["list"]);
-  list10(field);
+  list13(field);
 }
 
 // src/commands/xray/folder/add.ts
-function add2(parent) {
+function add3(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. PROJ)", text).requiredOption("--test <keys>", "Comma-separated test issue keys to add (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["818 --project PROJ --test PROJ-1", "818 --project PROJ --test PROJ-1,PROJ-2,PROJ-3"]);
   cmd.action(async (folderId, opts) => {
@@ -3258,7 +3079,7 @@ function add2(parent) {
 }
 
 // src/commands/xray/folder/create.ts
-function create8(parent) {
+function create10(parent) {
   const cmd = parent.command("create").description("Create a new folder in the test repository").requiredOption("--project <key>", "Project key (e.g. PROJ)", text).option("--parent-id <id>", "Parent folder id (-1 = root)", integer, -1).requiredOption("--name <text>", "Folder name", text);
   examples(cmd, [
     "--project PROJ --name Smoke",
@@ -3288,7 +3109,7 @@ function deleteFolder(parent) {
 }
 
 // src/commands/xray/folder/list.ts
-function list11(parent) {
+function list14(parent) {
   const cmd = parent.command("list").description("List the test repository folder tree for a project").requiredOption("--project <key>", "Project key (e.g. PROJ)", text);
   examples(cmd, ["--project PROJ", "--project PROJ"]);
   cmd.action(async (opts) => {
@@ -3299,7 +3120,7 @@ function list11(parent) {
 }
 
 // src/commands/xray/folder/remove.ts
-function remove2(parent) {
+function remove3(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. PROJ)", text).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["818 --project PROJ --test PROJ-1", "818 --project PROJ --test PROJ-1,PROJ-2"]);
   cmd.action(async (folderId, opts) => {
@@ -3337,28 +3158,28 @@ function update7(parent) {
 }
 
 // src/commands/xray/folder/index.ts
-function registerFolderCommands(xray) {
+function registerFolderCommands2(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 PROJ", "create --project PROJ --parent-id -1 --name Smoke"]);
-  list11(folder);
-  create8(folder);
+  list14(folder);
+  create10(folder);
   update7(folder);
   deleteFolder(folder);
-  add2(folder);
-  remove2(folder);
+  add3(folder);
+  remove3(folder);
 }
 
 // src/commands/xray/import/execution.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync } from "fs";
 import { basename as basename2 } from "path";
-import { Option as Option10 } from "commander";
+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 Option10(
+    new Option9(
       "--format <format>",
       "Result format. xray/cucumber/behave: JSON body, no --project/--execution required. junit/testng/nunit/xunit/robot: XML body, requires either --project or --execution."
     ).choices(FORMATS).makeOptionMandatory()
@@ -3383,7 +3204,7 @@ function execution(parent) {
           `--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 body = readFileSync(opts.file);
       const query = {};
       if (opts.project) query["projectKey"] = opts.project;
       if (opts.execution) query["testExecKey"] = opts.execution;
@@ -3404,13 +3225,13 @@ function execution(parent) {
 }
 
 // src/commands/xray/import/feature.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync2 } 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 PROJ"]);
   cmd.action(async (opts) => {
-    const fileBuffer = readFileSync5(opts.file);
+    const fileBuffer = readFileSync2(opts.file);
     const filename = basename3(opts.file);
     const client = getClient();
     const result = await client.xrayImport.importFeature({
@@ -3430,7 +3251,7 @@ function registerImportCommands(xray) {
 }
 
 // src/commands/xray/plan/add.ts
-function add3(parent) {
+function add4(parent) {
   const cmd = parent.command("add").description("Add tests and/or executions to a Test Plan").argument("<planKey>", "Test Plan issue key (e.g. PROJ-573)", issueKey).option("--test <keys>", "Comma-separated test issue keys to add (e.g. PROJ-1,PROJ-2)", keyList).option("--execution <keys>", "Comma-separated test execution keys to add (e.g. PROJ-200,PROJ-201)", keyList);
   examples(cmd, [
     "PROJ-573 --test PROJ-1,PROJ-2",
@@ -3449,7 +3270,7 @@ function add3(parent) {
 }
 
 // src/commands/xray/plan/create.ts
-function create9(parent) {
+function create11(parent) {
   const cmd = parent.command("create").description("Create a new Xray Test Plan issue").requiredOption("--project <key>", "Project key (e.g. PROJ)", text).requiredOption("--summary <text>", "Test Plan summary (title)", text);
   textOrFileOption(cmd, "description", { description: "Test Plan description" });
   examples(cmd, [
@@ -3481,7 +3302,7 @@ function deletePlan(parent) {
 }
 
 // src/commands/xray/plan/list.ts
-function list12(parent) {
+function list15(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. PROJ-574)", issueKey);
@@ -3494,7 +3315,7 @@ function list12(parent) {
 }
 
 // src/commands/xray/plan/remove.ts
-function remove3(parent) {
+function remove4(parent) {
   const cmd = parent.command("remove").description("Remove tests and/or executions from a Test Plan").argument("<planKey>", "Test Plan issue key (e.g. PROJ-573)", issueKey).option("--test <keys>", "Comma-separated test issue keys to remove (e.g. PROJ-1,PROJ-2)", keyList).option("--execution <keys>", "Comma-separated test execution keys to remove (e.g. PROJ-200)", keyList);
   examples(cmd, [
     "PROJ-573 --test PROJ-1",
@@ -3536,16 +3357,16 @@ function registerPlanCommands(xray) {
     "add PROJ-573 --test PROJ-1 --execution PROJ-200",
     "list --test PROJ-574"
   ]);
-  create9(plan);
+  create11(plan);
   update8(plan);
   deletePlan(plan);
-  add3(plan);
-  remove3(plan);
-  list12(plan);
+  add4(plan);
+  remove4(plan);
+  list15(plan);
 }
 
 // src/commands/xray/precondition/add.ts
-function add4(parent) {
+function add5(parent) {
   const cmd = parent.command("add").description("Add tests to a Pre-Condition").argument("<preKey>", "Pre-Condition issue key (e.g. PROJ-50)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to add (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["PROJ-50 --test PROJ-1", "PROJ-50 --test PROJ-1,PROJ-2,PROJ-3"]);
   cmd.action(async (preKey, opts) => {
@@ -3556,7 +3377,7 @@ function add4(parent) {
 }
 
 // src/commands/xray/precondition/create.ts
-import { Option as Option11 } from "commander";
+import { Option as Option10 } from "commander";
 
 // src/utils/xray/fields.ts
 var CONCEPT_SUFFIX = {
@@ -3657,11 +3478,11 @@ function buildPreconditionCustomFields(map, opts) {
 }
 
 // src/commands/xray/precondition/create.ts
-function create10(parent) {
+function create12(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 configured for it; it may not be on your project scheme."
   ).requiredOption("--project <key>", "Project key (e.g. PROJ)", text).requiredOption("--summary <text>", "Pre-Condition summary (title)", text).addOption(
-    new Option11("--type <type>", "Pre-Condition type").choices(["manual", "generic", "cucumber"]).default("manual")
+    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" });
@@ -3708,7 +3529,7 @@ function deletePrecondition(parent) {
 }
 
 // src/commands/xray/precondition/list.ts
-function list13(parent) {
+function list16(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. PROJ-584)", issueKey);
@@ -3721,7 +3542,7 @@ function list13(parent) {
 }
 
 // src/commands/xray/precondition/remove.ts
-function remove4(parent) {
+function remove5(parent) {
   const cmd = parent.command("remove").description("Remove tests from a Pre-Condition").argument("<preKey>", "Pre-Condition issue key (e.g. PROJ-50)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["PROJ-50 --test PROJ-1", "PROJ-50 --test PROJ-1,PROJ-2"]);
   cmd.action(async (preKey, opts) => {
@@ -3732,9 +3553,9 @@ function remove4(parent) {
 }
 
 // src/commands/xray/precondition/update.ts
-import { Option as Option12 } from "commander";
+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. PROJ-50)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option12("--type <type>", "New Pre-Condition type").choices(["manual", "generic", "cucumber"]));
+  const cmd = parent.command("update").description("Update an Xray Pre-Condition issue").argument("<preKey>", "Pre-Condition issue key (e.g. PROJ-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, ['PROJ-50 --summary "Updated precondition"', 'PROJ-50 --type generic --condition "apiKey != null"']);
@@ -3782,12 +3603,12 @@ function registerPreconditionCommands(xray) {
     "add PROJ-50 --test PROJ-1,PROJ-2",
     "list --test PROJ-584"
   ]);
-  create10(precondition);
+  create12(precondition);
   update9(precondition);
   deletePrecondition(precondition);
-  add4(precondition);
-  remove4(precondition);
-  list13(precondition);
+  add5(precondition);
+  remove5(precondition);
+  list16(precondition);
 }
 
 // src/utils/xray/run-id.ts
@@ -3801,7 +3622,7 @@ async function resolveRunId(client, o) {
 }
 
 // src/commands/xray/run/defect/add.ts
-function add5(parent) {
+function add6(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 PROJ-1 --test PROJ-2 --defect BUG-1,BUG-2"]);
   cmd.action(async (runId, opts) => {
@@ -3813,7 +3634,7 @@ function add5(parent) {
 }
 
 // src/commands/xray/run/defect/remove.ts
-function remove5(parent) {
+function remove6(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 PROJ-1 --test PROJ-2 --defect BUG-1,BUG-2"]);
   cmd.action(async (runId, opts) => {
@@ -3850,12 +3671,12 @@ function registerDefectCommands(run) {
     "Manage defects linked to a test run. See also: run update --defect for the one-command fail+link loop."
   );
   examples(defect, ["add --execution PROJ-1 --test PROJ-2 --defect BUG-1", "remove 42 --defect BUG-1"]);
-  add5(defect);
-  remove5(defect);
+  add6(defect);
+  remove6(defect);
 }
 
 // src/commands/xray/run/evidence/add.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { basename as basename4, extname } from "path";
 var CONTENT_TYPES = {
   ".png": "image/png",
@@ -3873,13 +3694,13 @@ var CONTENT_TYPES = {
 function inferContentType(fp) {
   return CONTENT_TYPES[extname(fp).toLowerCase()] ?? "application/octet-stream";
 }
-function add6(parent) {
+function add7(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 PROJ-1 --test PROJ-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 fileBuf = readFileSync3(opts.file);
     const filename = basename4(opts.file);
     const contentType = inferContentType(opts.file);
     const data = fileBuf.toString("base64");
@@ -3901,7 +3722,7 @@ function deleteEvidence(parent) {
 }
 
 // src/commands/xray/run/evidence/list.ts
-function list14(parent) {
+function list17(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 PROJ-1 --test PROJ-2"]);
   cmd.action(async (runId, opts) => {
@@ -3920,13 +3741,13 @@ function registerEvidenceCommands(run) {
     "list 42",
     "delete 42 --evidence-id 7"
   ]);
-  add6(evidence);
-  list14(evidence);
+  add7(evidence);
+  list17(evidence);
   deleteEvidence(evidence);
 }
 
 // src/commands/xray/run/field/get.ts
-function get8(parent) {
+function get10(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 PROJ-1 --test PROJ-2 --field-id customfield_10100"]);
   cmd.action(async (runId, opts) => {
@@ -3958,12 +3779,12 @@ function set(parent) {
 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"']);
-  get8(field);
+  get10(field);
   set(field);
 }
 
 // src/commands/xray/run/get.ts
-function get9(parent) {
+function get11(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 PROJ-1 --test PROJ-2"]);
   cmd.action(async (runId, opts) => {
@@ -3975,7 +3796,7 @@ function get9(parent) {
 }
 
 // src/commands/xray/run/list.ts
-function list15(parent) {
+function list18(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 PROJ-1", "--execution PROJ-1 --limit 10", "--execution PROJ-1 --limit 10 --start 10"]);
   cmd.action(async (opts) => {
@@ -3988,7 +3809,7 @@ function list15(parent) {
 }
 
 // src/commands/xray/run/step/list.ts
-function list16(parent) {
+function list19(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 PROJ-1 --test PROJ-2"]);
   cmd.action(async (runId, opts) => {
@@ -4035,7 +3856,7 @@ function update10(parent) {
 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 PROJ-1 --test PROJ-2", "update 42 --step-id 1 --status PASS"]);
-  list16(step);
+  list19(step);
   update10(step);
 }
 
@@ -4081,8 +3902,8 @@ function registerRunCommands(xray) {
     "step list --execution PROJ-1 --test PROJ-2",
     "field get 42 --field-id customfield_10100"
   ]);
-  get9(run);
-  list15(run);
+  get11(run);
+  list18(run);
   update11(run);
   registerDefectCommands(run);
   registerEvidenceCommands(run);
@@ -4091,7 +3912,7 @@ function registerRunCommands(xray) {
 }
 
 // src/commands/xray/status/list.ts
-function list17(parent) {
+function list20(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) => {
@@ -4105,11 +3926,11 @@ function list17(parent) {
 function registerStatusCommands(xray) {
   const status = xray.command("status").description("Xray status discovery");
   examples(status, ["list", ["list --step", "step statuses"]]);
-  list17(status);
+  list20(status);
 }
 
 // src/commands/xray/step/add.ts
-function add7(parent) {
+function add8(parent) {
   const cmd = parent.command("add").description("Add a manual test step to a Test issue").requiredOption("--test <key>", "Test issue key (e.g. PROJ-584)", issueKey);
   textOrFileOption(cmd, "action", { description: "Step action text (required: provide --action or --action-file)" });
   textOrFileOption(cmd, "data", { description: "Step test data text" });
@@ -4142,7 +3963,7 @@ function deleteStep(parent) {
 }
 
 // src/commands/xray/step/list.ts
-function list18(parent) {
+function list21(parent) {
   const cmd = parent.command("list").description("List manual test steps for a Test issue").requiredOption("--test <key>", "Test issue key (e.g. PROJ-584)", issueKey);
   examples(cmd, ["--test PROJ-584"]);
   cmd.action(async (opts) => {
@@ -4185,23 +4006,23 @@ function registerStepCommands(xray) {
     "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 PROJ-584 --action "Open login" --result "Form shows"', "list --test PROJ-584"]);
-  list18(step);
-  add7(step);
+  list21(step);
+  add8(step);
   update12(step);
   deleteStep(step);
 }
 
 // src/commands/xray/test/create.ts
-import { Option as Option13 } from "commander";
+import { Option as Option12 } from "commander";
 import { z as z5 } from "zod";
 var stepsSchema = z5.array(
   z5.object({ action: z5.string(), data: z5.string().optional(), result: z5.string().optional() })
 );
-function create11(parent) {
+function create13(parent) {
   const cmd = parent.command("create").description("Create a new Xray Test issue").requiredOption("--project <key>", "Project key (e.g. PROJ)", text).requiredOption("--summary <text>", "Test summary (title)", text).addOption(
-    new Option13("--type <type>", "Test type (when cucumber: also pass --gherkin; when generic: --definition)").choices(["manual", "cucumber", "generic"]).default("manual")
+    new Option12("--type <type>", "Test type (when cucumber: also pass --gherkin; when generic: --definition)").choices(["manual", "cucumber", "generic"]).default("manual")
   ).addOption(
-    new Option13("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
+    new Option12("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
       "scenario",
       "scenario-outline"
     ])
@@ -4286,7 +4107,7 @@ function deleteTest(parent) {
 }
 
 // src/commands/xray/test/get.ts
-function get10(parent) {
+function get12(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. PROJ-584)", listOf(issueKey));
   examples(cmd, ["PROJ-584", "PROJ-584 PROJ-585"]);
   cmd.action(async (testKeys) => {
@@ -4297,7 +4118,7 @@ function get10(parent) {
 }
 
 // src/commands/xray/test/list.ts
-function list19(parent) {
+function list22(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);
@@ -4371,10 +4192,10 @@ function list19(parent) {
 }
 
 // src/commands/xray/test/update.ts
-import { Option as Option14 } from "commander";
+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. PROJ-584)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option14("--type <type>", "Test type").choices(["manual", "cucumber", "generic"])).addOption(
-    new Option14("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
+  const cmd = parent.command("update").description("Update an Xray Test issue").argument("<testKey>", "Test issue key (e.g. PROJ-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"
     ])
@@ -4439,15 +4260,15 @@ function update13(parent) {
 function registerTestCommands(xray) {
   const test = xray.command("test").description("Xray Test issue management (CRUD)");
   examples(test, ["get PROJ-584", 'create --project PROJ --summary "Login" --type manual']);
-  get10(test);
-  create11(test);
+  get12(test);
+  create13(test);
   update13(test);
   deleteTest(test);
-  list19(test);
+  list22(test);
 }
 
 // src/commands/xray/testset/add.ts
-function add8(parent) {
+function add9(parent) {
   const cmd = parent.command("add").description("Add tests to a Test Set").argument("<setKey>", "Test Set issue key (e.g. PROJ-100)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to add (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["PROJ-100 --test PROJ-1", "PROJ-100 --test PROJ-1,PROJ-2,PROJ-3"]);
   cmd.action(async (setKey, opts) => {
@@ -4458,7 +4279,7 @@ function add8(parent) {
 }
 
 // src/commands/xray/testset/create.ts
-function create12(parent) {
+function create14(parent) {
   const cmd = parent.command("create").description("Create a new Xray Test Set issue").requiredOption("--project <key>", "Project key (e.g. PROJ)", text).requiredOption("--summary <text>", "Test Set summary (title)", text);
   textOrFileOption(cmd, "description", { description: "Test Set description" });
   examples(cmd, [
@@ -4490,7 +4311,7 @@ function deleteTestset(parent) {
 }
 
 // src/commands/xray/testset/list.ts
-function list20(parent) {
+function list23(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. PROJ-584)", issueKey);
@@ -4503,7 +4324,7 @@ function list20(parent) {
 }
 
 // src/commands/xray/testset/remove.ts
-function remove6(parent) {
+function remove7(parent) {
   const cmd = parent.command("remove").description("Remove tests from a Test Set").argument("<setKey>", "Test Set issue key (e.g. PROJ-100)", issueKey).requiredOption("--test <keys>", "Comma-separated test issue keys to remove (e.g. PROJ-1,PROJ-2)", keyList);
   examples(cmd, ["PROJ-100 --test PROJ-1", "PROJ-100 --test PROJ-1,PROJ-2"]);
   cmd.action(async (setKey, opts) => {
@@ -4532,12 +4353,12 @@ function registerTestsetCommands(xray) {
     "Xray Test Set issue management (CRUD, membership). To list tests inside a set, use: xray test list --set <key>"
   );
   examples(testset, ['create --project PROJ --summary "Smoke tests"', "add PROJ-100 --test PROJ-1,PROJ-2"]);
-  create12(testset);
+  create14(testset);
   update14(testset);
   deleteTestset(testset);
-  add8(testset);
-  remove6(testset);
-  list20(testset);
+  add9(testset);
+  remove7(testset);
+  list23(testset);
 }
 
 // src/commands/xray/index.ts
@@ -4553,7 +4374,7 @@ function registerXrayCommands(program) {
   registerPlanCommands(xray);
   registerStepCommands(xray);
   registerRunCommands(xray);
-  registerFolderCommands(xray);
+  registerFolderCommands2(xray);
   registerImportCommands(xray);
   registerExportCommands(xray);
 }
@@ -4600,6 +4421,7 @@ ${styleText("bold", "Examples:")}
   registerFieldCommands(program);
   registerUserCommands(program);
   registerTokenCommands(program);
+  registerStructureCommands(program);
   registerXrayCommands(program);
   return program;
 }