@unbrained/pm-cli 2026.5.29 → 2026.5.31

package/dist/cli-bundle/chunks/chunk-P53TN6IA.js

@@ -0,0 +1,674 @@
+import {
+  ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
+  CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
+  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+  CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
+  LIST_COMMANDER_STRING_OPTION_CONTRACTS,
+  SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
+  UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+  UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
+  readFirstStringFromCommanderOptions,
+  readStringArrayFromCommanderOptions
+} from "./chunk-GN7IJPCD.js";
+import {
+  refreshSearchArtifactsForMutation,
+  shouldRunSearchRefreshInForeground
+} from "./chunk-6HT2F4TK.js";
+import {
+  printError,
+  writeStdout
+} from "./chunk-5HSEP75M.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  getSettingsPath,
+  pathExists,
+  readSettings,
+  resolvePmRoot,
+  setActiveCommandResult
+} from "./chunk-LSXGH6NE.js";
+
+// dist/cli/registration-helpers.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "04b7017e-0276-58fe-a000-5744fc740226");
+  } catch (e2) {
+  }
+})();
+var RESOLVED_GLOBAL_OPTIONS = /* @__PURE__ */ Symbol("pm.resolvedGlobalOptions");
+function commandOptionsReader(command) {
+  return typeof command === "object" && command !== null ? command : {};
+}
+function setResolvedGlobalOptions(command, globalOptions) {
+  command[RESOLVED_GLOBAL_OPTIONS] = { ...globalOptions };
+}
+function clearResolvedGlobalOptions(command) {
+  delete command[RESOLVED_GLOBAL_OPTIONS];
+}
+function getGlobalOptions(command) {
+  const resolved = command[RESOLVED_GLOBAL_OPTIONS];
+  if (resolved) {
+    return { ...resolved };
+  }
+  const reader = commandOptionsReader(command);
+  const opts = typeof reader.optsWithGlobals === "function" ? reader.optsWithGlobals() : typeof reader.opts === "function" ? reader.opts() : {};
+  return {
+    json: opts.json === true ? true : void 0,
+    quiet: Boolean(opts.quiet),
+    noChangedFields: opts.changedFields === false,
+    path: typeof opts.path === "string" ? opts.path : void 0,
+    noExtensions: opts.extensions === false,
+    noPager: Boolean(opts.noPager),
+    profile: Boolean(opts.profile)
+  };
+}
+function getCommandPath(command) {
+  const parts = [];
+  let current = command;
+  while (current?.parent) {
+    parts.unshift(current.name());
+    current = current.parent;
+  }
+  return parts.join(" ");
+}
+async function applyDefaultOutputFormat(globalOptions) {
+  if (globalOptions.json === true) {
+    return globalOptions;
+  }
+  const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    return globalOptions;
+  }
+  const settings = await readSettings(pmRoot);
+  return {
+    ...globalOptions,
+    defaultOutputFormat: settings.output.default_format
+  };
+}
+function collect(value, previous) {
+  const next = previous ?? [];
+  next.push(value);
+  return next;
+}
+function pushOptionalValueFlag(args, flag, value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  args.push(flag, trimmed);
+}
+function pushOptionalBooleanFlag(args, flag, value) {
+  if (value === true) {
+    args.push(flag);
+  }
+}
+function pushRepeatableValueFlag(args, flag, values) {
+  if (!Array.isArray(values)) {
+    return;
+  }
+  for (const value of values) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    args.push(flag, trimmed);
+  }
+}
+function buildBackgroundTestCommandArgs(id, options) {
+  const args = ["test", id, "--run", "--json", "--progress"];
+  pushRepeatableValueFlag(args, "--add", options.add);
+  pushRepeatableValueFlag(args, "--remove", options.remove);
+  pushOptionalValueFlag(args, "--timeout", options.timeout);
+  pushRepeatableValueFlag(args, "--env-set", options.envSet);
+  pushRepeatableValueFlag(args, "--env-clear", options.envClear);
+  pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
+  pushOptionalValueFlag(args, "--pm-context", options.pmContext);
+  pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+  pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
+  pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
+  pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
+  pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
+  pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
+  pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
+  pushOptionalValueFlag(args, "--author", options.author);
+  pushOptionalValueFlag(args, "--message", options.message);
+  pushOptionalBooleanFlag(args, "--force", options.force);
+  return args;
+}
+function buildBackgroundTestAllCommandArgs(options) {
+  const args = ["test-all", "--json", "--progress"];
+  pushOptionalValueFlag(args, "--status", options.status);
+  pushOptionalValueFlag(args, "--limit", options.limit);
+  pushOptionalValueFlag(args, "--offset", options.offset);
+  pushOptionalValueFlag(args, "--timeout", options.timeout);
+  pushRepeatableValueFlag(args, "--env-set", options.envSet);
+  pushRepeatableValueFlag(args, "--env-clear", options.envClear);
+  pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
+  pushOptionalValueFlag(args, "--pm-context", options.pmContext);
+  pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+  pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
+  pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
+  pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
+  pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
+  pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
+  pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
+  return args;
+}
+function formatHookWarnings(warnings) {
+  return warnings.join(",");
+}
+function normalizeCreateOptions(commandOptions, options = {}) {
+  const readCreateString = (target) => readFirstStringFromCommanderOptions(commandOptions, CREATE_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  const readCreateList = (target) => readStringArrayFromCommanderOptions(commandOptions, CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  const type = readCreateString("type");
+  if (options.requireType !== false && type === void 0) {
+    throw new PmCliError("Missing required option --type <value>. Why required: create resolves runtime schema fields/workflow from item type. Retry: add --type <built-in or configured custom type> (example: --type Task).", EXIT_CODE.USAGE);
+  }
+  const normalized = {
+    title: readCreateString("title"),
+    description: readCreateString("description"),
+    type,
+    template: readCreateString("template"),
+    createMode: readCreateString("createMode"),
+    schedulePreset: readCreateString("schedulePreset"),
+    status: readCreateString("status"),
+    priority: readCreateString("priority"),
+    tags: readCreateString("tags"),
+    addTags: readCreateList("addTags"),
+    body: readCreateString("body"),
+    deadline: readCreateString("deadline"),
+    estimatedMinutes: readCreateString("estimatedMinutes"),
+    acceptanceCriteria: readCreateString("acceptanceCriteria"),
+    definitionOfReady: readCreateString("definitionOfReady"),
+    order: readCreateString("order"),
+    rank: readCreateString("rank"),
+    goal: readCreateString("goal"),
+    objective: readCreateString("objective"),
+    value: readCreateString("value"),
+    impact: readCreateString("impact"),
+    outcome: readCreateString("outcome"),
+    whyNow: readCreateString("whyNow"),
+    author: readCreateString("author"),
+    message: readCreateString("message"),
+    assignee: readCreateString("assignee"),
+    parent: readCreateString("parent"),
+    reviewer: readCreateString("reviewer"),
+    risk: readCreateString("risk"),
+    confidence: readCreateString("confidence"),
+    sprint: readCreateString("sprint"),
+    release: readCreateString("release"),
+    blockedBy: readCreateString("blockedBy"),
+    blockedReason: readCreateString("blockedReason"),
+    unblockNote: readCreateString("unblockNote"),
+    reporter: readCreateString("reporter"),
+    severity: readCreateString("severity"),
+    environment: readCreateString("environment"),
+    reproSteps: readCreateString("reproSteps"),
+    resolution: readCreateString("resolution"),
+    expectedResult: readCreateString("expectedResult"),
+    actualResult: readCreateString("actualResult"),
+    affectedVersion: readCreateString("affectedVersion"),
+    fixedVersion: readCreateString("fixedVersion"),
+    component: readCreateString("component"),
+    regression: readCreateString("regression"),
+    customerImpact: readCreateString("customerImpact"),
+    dep: readCreateList("dep"),
+    comment: readCreateList("comment"),
+    note: readCreateList("note"),
+    learning: readCreateList("learning"),
+    file: readCreateList("file"),
+    test: readCreateList("test"),
+    doc: readCreateList("doc"),
+    reminder: readCreateList("reminder"),
+    event: readCreateList("event"),
+    typeOption: readCreateList("typeOption"),
+    unset: readCreateList("unset"),
+    clearDeps: commandOptions.clearDeps === true ? true : void 0,
+    clearComments: commandOptions.clearComments === true ? true : void 0,
+    clearNotes: commandOptions.clearNotes === true ? true : void 0,
+    clearLearnings: commandOptions.clearLearnings === true ? true : void 0,
+    clearFiles: commandOptions.clearFiles === true ? true : void 0,
+    clearTests: commandOptions.clearTests === true ? true : void 0,
+    clearDocs: commandOptions.clearDocs === true ? true : void 0,
+    clearReminders: commandOptions.clearReminders === true ? true : void 0,
+    clearEvents: commandOptions.clearEvents === true ? true : void 0,
+    clearTypeOptions: commandOptions.clearTypeOptions === true ? true : void 0
+  };
+  for (const [key, value] of Object.entries(commandOptions)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function normalizeUpdateOptions(commandOptions) {
+  const readUpdateString = (target) => readFirstStringFromCommanderOptions(commandOptions, UPDATE_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  const readUpdateList = (target) => readStringArrayFromCommanderOptions(commandOptions, UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  const normalized = {
+    title: readUpdateString("title"),
+    description: readUpdateString("description"),
+    body: readUpdateString("body"),
+    status: readUpdateString("status"),
+    closeReason: readUpdateString("closeReason"),
+    priority: readUpdateString("priority"),
+    type: readUpdateString("type"),
+    tags: readUpdateString("tags"),
+    addTags: readUpdateList("addTags"),
+    removeTags: readUpdateList("removeTags"),
+    deadline: readUpdateString("deadline"),
+    estimatedMinutes: readUpdateString("estimatedMinutes"),
+    acceptanceCriteria: readUpdateString("acceptanceCriteria"),
+    definitionOfReady: readUpdateString("definitionOfReady"),
+    order: readUpdateString("order"),
+    rank: readUpdateString("rank"),
+    goal: readUpdateString("goal"),
+    objective: readUpdateString("objective"),
+    value: readUpdateString("value"),
+    impact: readUpdateString("impact"),
+    outcome: readUpdateString("outcome"),
+    whyNow: readUpdateString("whyNow"),
+    author: readUpdateString("author"),
+    message: readUpdateString("message"),
+    force: Boolean(commandOptions.force),
+    allowAuditUpdate: commandOptions.allowAuditUpdate === true || commandOptions.allow_audit_update === true ? true : void 0,
+    allowAuditDepUpdate: commandOptions.allowAuditDepUpdate === true || commandOptions.allow_audit_dep_update === true ? true : void 0,
+    assignee: readUpdateString("assignee"),
+    parent: readUpdateString("parent"),
+    reviewer: readUpdateString("reviewer"),
+    risk: readUpdateString("risk"),
+    confidence: readUpdateString("confidence"),
+    sprint: readUpdateString("sprint"),
+    release: readUpdateString("release"),
+    blockedBy: readUpdateString("blockedBy"),
+    blockedReason: readUpdateString("blockedReason"),
+    unblockNote: readUpdateString("unblockNote"),
+    reporter: readUpdateString("reporter"),
+    severity: readUpdateString("severity"),
+    environment: readUpdateString("environment"),
+    reproSteps: readUpdateString("reproSteps"),
+    resolution: readUpdateString("resolution"),
+    expectedResult: readUpdateString("expectedResult"),
+    actualResult: readUpdateString("actualResult"),
+    affectedVersion: readUpdateString("affectedVersion"),
+    fixedVersion: readUpdateString("fixedVersion"),
+    component: readUpdateString("component"),
+    regression: readUpdateString("regression"),
+    customerImpact: readUpdateString("customerImpact"),
+    dep: readUpdateList("dep"),
+    depRemove: readUpdateList("depRemove"),
+    replaceDeps: commandOptions.replaceDeps === true ? true : void 0,
+    replaceTests: commandOptions.replaceTests === true ? true : void 0,
+    comment: readUpdateList("comment"),
+    note: readUpdateList("note"),
+    learning: readUpdateList("learning"),
+    file: readUpdateList("file"),
+    test: readUpdateList("test"),
+    doc: readUpdateList("doc"),
+    reminder: readUpdateList("reminder"),
+    event: readUpdateList("event"),
+    typeOption: readUpdateList("typeOption"),
+    unset: readUpdateList("unset"),
+    clearDeps: commandOptions.clearDeps === true ? true : void 0,
+    clearComments: commandOptions.clearComments === true ? true : void 0,
+    clearNotes: commandOptions.clearNotes === true ? true : void 0,
+    clearLearnings: commandOptions.clearLearnings === true ? true : void 0,
+    clearFiles: commandOptions.clearFiles === true ? true : void 0,
+    clearTests: commandOptions.clearTests === true ? true : void 0,
+    clearDocs: commandOptions.clearDocs === true ? true : void 0,
+    clearReminders: commandOptions.clearReminders === true ? true : void 0,
+    clearEvents: commandOptions.clearEvents === true ? true : void 0,
+    clearTypeOptions: commandOptions.clearTypeOptions === true ? true : void 0
+  };
+  for (const [key, value] of Object.entries(commandOptions)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+var UPDATE_MANY_CONTROL_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "filterStatus",
+  "filterType",
+  "filterTag",
+  "filterPriority",
+  "filterDeadlineBefore",
+  "filterDeadlineAfter",
+  "filterAssignee",
+  "filterAssigneeFilter",
+  "filterAssignee_filter",
+  "filterParent",
+  "filterSprint",
+  "filterRelease",
+  "limit",
+  "offset",
+  "dryRun",
+  "rollback",
+  "checkpoint"
+]);
+function extractUpdateManyMutationOptionSource(commandOptions) {
+  const mutationOptions = {};
+  for (const [key, value] of Object.entries(commandOptions)) {
+    if (UPDATE_MANY_CONTROL_OPTION_KEYS.has(key)) {
+      continue;
+    }
+    mutationOptions[key] = value;
+  }
+  return mutationOptions;
+}
+function readListOptionString(options, target) {
+  return readFirstStringFromCommanderOptions(options, LIST_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+}
+function normalizeListOptions(options) {
+  const normalized = {
+    status: readListOptionString(options, "status"),
+    type: readListOptionString(options, "type"),
+    tag: readListOptionString(options, "tag"),
+    priority: readListOptionString(options, "priority"),
+    deadlineBefore: readListOptionString(options, "deadlineBefore"),
+    deadlineAfter: readListOptionString(options, "deadlineAfter"),
+    assignee: readListOptionString(options, "assignee"),
+    assigneeFilter: readListOptionString(options, "assigneeFilter"),
+    parent: readListOptionString(options, "parent"),
+    sprint: readListOptionString(options, "sprint"),
+    release: readListOptionString(options, "release"),
+    limit: readListOptionString(options, "limit"),
+    offset: readListOptionString(options, "offset"),
+    includeBody: options.includeBody === true ? true : void 0,
+    compact: options.compact === true ? true : void 0,
+    brief: options.brief === true ? true : void 0,
+    full: options.full === true ? true : void 0,
+    fields: readListOptionString(options, "fields"),
+    sort: readListOptionString(options, "sort"),
+    order: readListOptionString(options, "order")
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function normalizeAggregateOptions(options) {
+  return {
+    groupBy: typeof options.groupBy === "string" ? options.groupBy : void 0,
+    count: options.count === true ? true : void 0,
+    includeUnparented: options.includeUnparented === true || options.include_unparented === true,
+    status: typeof options.status === "string" ? options.status : void 0,
+    type: readListOptionString(options, "type"),
+    tag: readListOptionString(options, "tag"),
+    priority: readListOptionString(options, "priority"),
+    deadlineBefore: readListOptionString(options, "deadlineBefore"),
+    deadlineAfter: readListOptionString(options, "deadlineAfter"),
+    assignee: readListOptionString(options, "assignee"),
+    assigneeFilter: readListOptionString(options, "assigneeFilter"),
+    parent: readListOptionString(options, "parent"),
+    sprint: readListOptionString(options, "sprint"),
+    release: readListOptionString(options, "release")
+  };
+}
+function printListJsonStream(commandName, result, globalOptions) {
+  setActiveCommandResult(result);
+  if (globalOptions.quiet) {
+    return;
+  }
+  const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+  const metaPayload = {
+    type: "meta",
+    command: commandName,
+    count: result.count,
+    now: result.now,
+    filters: result.filters
+  };
+  if (warnings.length > 0) {
+    metaPayload.warnings = warnings;
+  }
+  if (!writeStdout(`${JSON.stringify(metaPayload)}
+`)) {
+    return;
+  }
+  for (const item of result.items) {
+    if (!writeStdout(`${JSON.stringify({ type: "item", command: commandName, item })}
+`)) {
+      return;
+    }
+  }
+  writeStdout(`${JSON.stringify({ type: "end", command: commandName, count: result.count })}
+`);
+}
+function printActivityJsonStream(result, options, globalOptions) {
+  setActiveCommandResult(result);
+  if (globalOptions.quiet) {
+    return;
+  }
+  const metaPayload = {
+    type: "meta",
+    command: "activity",
+    count: result.count,
+    filters: {
+      id: options.id ?? null,
+      op: options.op ?? null,
+      author: options.author ?? null,
+      from: options.from ?? null,
+      to: options.to ?? null,
+      limit: options.limit ?? null
+    }
+  };
+  if (!writeStdout(`${JSON.stringify(metaPayload)}
+`)) {
+    return;
+  }
+  const entries = result.compact && result.compact_activity ? result.compact_activity : result.activity;
+  for (const entry of entries) {
+    if (!writeStdout(`${JSON.stringify({ type: "entry", command: "activity", entry })}
+`)) {
+      return;
+    }
+  }
+  writeStdout(`${JSON.stringify({ type: "end", command: "activity", count: result.count })}
+`);
+}
+function normalizeSearchOptions(options) {
+  const readSearchString = (target) => readFirstStringFromCommanderOptions(options, SEARCH_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  const fields = readSearchString("fields");
+  const compactRequested = options.compact === true;
+  const fullRequested = options.full === true;
+  const defaultCompact = !compactRequested && !fullRequested && fields === void 0;
+  const mode = options.semantic === true ? "semantic" : options.hybrid === true ? "hybrid" : readSearchString("mode");
+  const normalized = {
+    mode,
+    includeLinked: options.includeLinked === true ? true : void 0,
+    titleExact: options.titleExact === true ? true : void 0,
+    phraseExact: options.phraseExact === true ? true : void 0,
+    type: readSearchString("type"),
+    tag: readSearchString("tag"),
+    priority: readSearchString("priority"),
+    deadlineBefore: readSearchString("deadlineBefore"),
+    deadlineAfter: readSearchString("deadlineAfter"),
+    limit: readSearchString("limit"),
+    fields,
+    compact: compactRequested || defaultCompact ? true : void 0,
+    full: fullRequested ? true : void 0
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function normalizeSearchKeywordsInput(keywords) {
+  const query = keywords.map((entry) => entry.trim()).filter((entry) => entry.length > 0).join(" ");
+  if (query.length === 0) {
+    throw new PmCliError("Search query must not be empty", EXIT_CODE.USAGE);
+  }
+  return query;
+}
+function normalizeActivityOptions(options) {
+  const readActivityString = (target) => readFirstStringFromCommanderOptions(options, ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  return {
+    id: readActivityString("id"),
+    op: readActivityString("op"),
+    author: readActivityString("author"),
+    from: readActivityString("from"),
+    to: readActivityString("to"),
+    limit: readActivityString("limit"),
+    compact: options.full === true ? false : options.compact === false ? false : true
+  };
+}
+function resolveActivityStreamMode(raw) {
+  if (raw === true) {
+    return true;
+  }
+  if (raw === false || raw === void 0 || raw === null) {
+    return false;
+  }
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized.length === 0 || normalized === "rows" || normalized === "ndjson" || normalized === "jsonl" || normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "off" || normalized === "none" || normalized === "0") {
+      return false;
+    }
+  }
+  throw new PmCliError("Activity --stream accepts rows|ndjson|jsonl (or no value)", EXIT_CODE.USAGE);
+}
+function normalizeContextOptions(options) {
+  const readContextString = (target) => readFirstStringFromCommanderOptions(options, CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+    target,
+    keys: [target]
+  });
+  const sectionRaw = options.section;
+  const section = Array.isArray(sectionRaw) ? sectionRaw.filter((v) => typeof v === "string" && v.trim().length > 0) : typeof sectionRaw === "string" && sectionRaw.trim().length > 0 ? [sectionRaw] : void 0;
+  const normalized = {
+    date: readContextString("date"),
+    from: readContextString("from"),
+    to: readContextString("to"),
+    past: options.past === true ? true : void 0,
+    type: readContextString("type"),
+    tag: readContextString("tag"),
+    priority: readContextString("priority"),
+    assignee: readContextString("assignee"),
+    assigneeFilter: readContextString("assigneeFilter"),
+    sprint: readContextString("sprint"),
+    release: readContextString("release"),
+    limit: readContextString("limit"),
+    format: readContextString("format"),
+    depth: readContextString("depth"),
+    section: section && section.length > 0 ? section : void 0,
+    activityLimit: readContextString("activityLimit"),
+    staleThreshold: readContextString("staleThreshold")
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (Object.hasOwn(normalized, key)) {
+      continue;
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function collectMutationItemIds(result) {
+  if (!result || typeof result !== "object") {
+    return [];
+  }
+  const record = result;
+  const ids = /* @__PURE__ */ new Set();
+  const pushId = (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+      return;
+    }
+    ids.add(normalized);
+  };
+  pushId(record.id);
+  const item = record.item;
+  if (item && typeof item === "object") {
+    pushId(item.id);
+  }
+  const explicitIds = record.ids;
+  if (Array.isArray(explicitIds)) {
+    for (const candidate of explicitIds) {
+      pushId(candidate);
+    }
+  }
+  const items = record.items;
+  if (Array.isArray(items)) {
+    for (const candidate of items) {
+      if (!candidate || typeof candidate !== "object") {
+        continue;
+      }
+      pushId(candidate.id);
+    }
+  }
+  return [...ids].sort((left, right) => left.localeCompare(right));
+}
+async function invalidateSearchCachesForMutation(globalOptions, result) {
+  const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+  const refreshResult = await refreshSearchArtifactsForMutation(pmRoot, collectMutationItemIds(result), {
+    background: !shouldRunSearchRefreshInForeground()
+  });
+  if (globalOptions.profile && refreshResult.warnings.length > 0) {
+    printError(`profile:search_refresh_warnings=${formatHookWarnings(refreshResult.warnings)}`);
+  }
+}
+
+export {
+  setResolvedGlobalOptions,
+  clearResolvedGlobalOptions,
+  getGlobalOptions,
+  getCommandPath,
+  applyDefaultOutputFormat,
+  collect,
+  buildBackgroundTestCommandArgs,
+  buildBackgroundTestAllCommandArgs,
+  formatHookWarnings,
+  normalizeCreateOptions,
+  normalizeUpdateOptions,
+  extractUpdateManyMutationOptionSource,
+  normalizeListOptions,
+  normalizeAggregateOptions,
+  printListJsonStream,
+  printActivityJsonStream,
+  normalizeSearchOptions,
+  normalizeSearchKeywordsInput,
+  normalizeActivityOptions,
+  resolveActivityStreamMode,
+  normalizeContextOptions,
+  invalidateSearchCachesForMutation
+};
+//# sourceMappingURL=chunk-P53TN6IA.js.map