@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/update-many-DC7X3EWM.js

@@ -1,671 +0,0 @@
-import {
-  createCheckpointId,
-  loadMutationCheckpoint,
-  restoreCheckpointItems,
-  writeMutationCheckpoint
-} from "./chunk-YQMMMONE.js";
-import {
-  runRestore
-} from "./chunk-ABRA3BHY.js";
-import {
-  resolveAuthor
-} from "./chunk-WW4E2DC3.js";
-import "./chunk-3Y4OESPP.js";
-import "./chunk-D3UCE7RW.js";
-import {
-  runUpdate
-} from "./chunk-YMABYTNG.js";
-import {
-  resolvePriority
-} from "./chunk-MTTXDAK4.js";
-import "./chunk-BVEUCSH2.js";
-import {
-  applyTagRemovals,
-  mergeAdditiveTags,
-  parseTags
-} from "./chunk-T3ABIMGW.js";
-import "./chunk-ZMD35NYG.js";
-import "./chunk-FGQKEDE4.js";
-import {
-  hasListFilters
-} from "./chunk-4BU75MF4.js";
-import "./chunk-YOF5VPKM.js";
-import {
-  runList
-} from "./chunk-7EQNAZX2.js";
-import "./chunk-R23CSHGI.js";
-import "./chunk-RX3HQSYG.js";
-import "./chunk-EEY54JMF.js";
-import "./chunk-ZD34OFFQ.js";
-import "./chunk-CZVISY5A.js";
-import "./chunk-5HIZDR5A.js";
-import {
-  toItemRecord
-} from "./chunk-3U3VEWK6.js";
-import "./chunk-OWTIRHX4.js";
-import {
-  collectRuntimeUpdateFieldValues,
-  normalizeStatusInput
-} from "./chunk-EZFKWSC7.js";
-import {
-  nowIso,
-  resolveIsoOrRelative
-} from "./chunk-DRBV5UC2.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  stableValueEquals
-} from "./chunk-P5YORJRH.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-T35XLYZF.js";
-import "./chunk-7C2O74AE.js";
-import {
-  EXIT_CODE,
-  getSettingsPath,
-  pathExists,
-  resolveItemTypeRegistry,
-  resolveItemTypesFilePath,
-  resolvePmRoot,
-  resolveRuntimeFieldRegistry,
-  resolveRuntimeStatusRegistry,
-  resolveTypeName,
-  toErrorMessage
-} from "./chunk-5VVUKE3U.js";
-
-// dist/cli/commands/update-many.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] = "d51d075c-2686-52c7-9070-cf81f2660d81");
-  } catch (e2) {
-  }
-})();
-var UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION = 1;
-var UPDATE_MANY_CHECKPOINT_SUBDIR = "update-many";
-var NON_MUTATION_UPDATE_OPTION_KEYS = /* @__PURE__ */ new Set([
-  "author",
-  "message",
-  "force",
-  "allowAuditUpdate",
-  "allowAuditDepUpdate"
-]);
-var UPDATE_MANY_MUTATION_FLAG_GUIDANCE = [
-  "--status",
-  "--priority",
-  "--type",
-  "--tags",
-  "--description",
-  "--body",
-  "--deadline",
-  "--estimate",
-  "--assignee",
-  "--dep",
-  "--dep-remove",
-  "--comment",
-  "--note",
-  "--learning",
-  "--file",
-  "--test",
-  "--doc",
-  "--replace-deps",
-  "--replace-tests",
-  "--unset",
-  "--clear-*"
-].join(", ");
-var UPDATE_OPTION_TO_ITEM_KEY = {
-  title: "title",
-  description: "description",
-  body: "body",
-  status: "status",
-  closeReason: "close_reason",
-  priority: "priority",
-  type: "type",
-  deadline: "deadline",
-  estimatedMinutes: "estimated_minutes",
-  acceptanceCriteria: "acceptance_criteria",
-  definitionOfReady: "definition_of_ready",
-  order: "order",
-  goal: "goal",
-  objective: "objective",
-  value: "value",
-  impact: "impact",
-  outcome: "outcome",
-  whyNow: "why_now",
-  assignee: "assignee",
-  parent: "parent",
-  reviewer: "reviewer",
-  risk: "risk",
-  confidence: "confidence",
-  sprint: "sprint",
-  release: "release",
-  blockedBy: "blocked_by",
-  blockedReason: "blocked_reason",
-  unblockNote: "unblock_note",
-  reporter: "reporter",
-  severity: "severity",
-  environment: "environment",
-  reproSteps: "repro_steps",
-  resolution: "resolution",
-  expectedResult: "expected_result",
-  actualResult: "actual_result",
-  affectedVersion: "affected_version",
-  fixedVersion: "fixed_version",
-  component: "component",
-  regression: "regression",
-  customerImpact: "customer_impact"
-};
-var COLLECTION_MUTATION_PLAN_DEFINITIONS = [
-  {
-    field: "dependencies",
-    addKey: "dep",
-    removeKey: "depRemove",
-    clearKey: "clearDeps",
-    replaceKey: "replaceDeps"
-  },
-  {
-    field: "comments",
-    addKey: "comment",
-    clearKey: "clearComments"
-  },
-  {
-    field: "notes",
-    addKey: "note",
-    clearKey: "clearNotes"
-  },
-  {
-    field: "learnings",
-    addKey: "learning",
-    clearKey: "clearLearnings"
-  },
-  {
-    field: "files",
-    addKey: "file",
-    clearKey: "clearFiles"
-  },
-  {
-    field: "tests",
-    addKey: "test",
-    clearKey: "clearTests",
-    replaceKey: "replaceTests"
-  },
-  {
-    field: "docs",
-    addKey: "doc",
-    clearKey: "clearDocs"
-  },
-  {
-    field: "reminders",
-    addKey: "reminder",
-    clearKey: "clearReminders"
-  },
-  {
-    field: "events",
-    addKey: "event",
-    clearKey: "clearEvents"
-  },
-  {
-    field: "type_options",
-    addKey: "typeOption",
-    clearKey: "clearTypeOptions"
-  }
-];
-var UNSET_FIELD_ALIASES = {
-  close_reason: "close_reason",
-  "close-reason": "close_reason",
-  deadline: "deadline",
-  estimate: "estimated_minutes",
-  estimated_minutes: "estimated_minutes",
-  "estimated-minutes": "estimated_minutes",
-  acceptance_criteria: "acceptance_criteria",
-  "acceptance-criteria": "acceptance_criteria",
-  ac: "acceptance_criteria",
-  definition_of_ready: "definition_of_ready",
-  "definition-of-ready": "definition_of_ready",
-  order: "order",
-  rank: "order",
-  goal: "goal",
-  objective: "objective",
-  value: "value",
-  impact: "impact",
-  outcome: "outcome",
-  why_now: "why_now",
-  "why-now": "why_now",
-  assignee: "assignee",
-  parent: "parent",
-  reviewer: "reviewer",
-  risk: "risk",
-  confidence: "confidence",
-  sprint: "sprint",
-  release: "release",
-  blocked_by: "blocked_by",
-  "blocked-by": "blocked_by",
-  blocked_reason: "blocked_reason",
-  "blocked-reason": "blocked_reason",
-  unblock_note: "unblock_note",
-  "unblock-note": "unblock_note",
-  reporter: "reporter",
-  severity: "severity",
-  environment: "environment",
-  repro_steps: "repro_steps",
-  "repro-steps": "repro_steps",
-  resolution: "resolution",
-  expected_result: "expected_result",
-  "expected-result": "expected_result",
-  actual_result: "actual_result",
-  "actual-result": "actual_result",
-  affected_version: "affected_version",
-  "affected-version": "affected_version",
-  fixed_version: "fixed_version",
-  "fixed-version": "fixed_version",
-  component: "component",
-  regression: "regression",
-  customer_impact: "customer_impact",
-  "customer-impact": "customer_impact",
-  type_options: "type_options",
-  "type-options": "type_options",
-  tags: "tags"
-};
-function sanitizeUpdateOptionsForSummary(options) {
-  const summary = {};
-  for (const [key, value] of Object.entries(options)) {
-    if (NON_MUTATION_UPDATE_OPTION_KEYS.has(key)) {
-      continue;
-    }
-    if (value === void 0) {
-      continue;
-    }
-    summary[key] = value;
-  }
-  return summary;
-}
-function hasAnyUpdateMutationInput(options) {
-  return Object.keys(sanitizeUpdateOptionsForSummary(options)).length > 0;
-}
-function toComparablePreviewValue(optionKey, value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (optionKey === "priority") {
-    const parsed = Number(String(value).trim());
-    return Number.isInteger(parsed) ? parsed : String(value).trim();
-  }
-  if (optionKey === "estimatedMinutes" || optionKey === "order" || optionKey === "rank") {
-    const parsed = Number(String(value).trim());
-    return Number.isFinite(parsed) ? parsed : String(value).trim();
-  }
-  if (optionKey === "regression") {
-    const normalized = String(value).trim().toLowerCase();
-    if (normalized === "true" || normalized === "1") {
-      return true;
-    }
-    if (normalized === "false" || normalized === "0") {
-      return false;
-    }
-  }
-  if (typeof value === "string") {
-    return value.trim();
-  }
-  return value;
-}
-function normalizeUnsetField(rawField) {
-  const normalized = rawField.trim().toLowerCase().replaceAll("-", "_");
-  return UNSET_FIELD_ALIASES[normalized] ?? normalized;
-}
-function areValuesEqual(left, right) {
-  return stableValueEquals(left, right);
-}
-function normalizeCollectionBeforeValue(field, value) {
-  if (value !== void 0) {
-    return value;
-  }
-  if (field === "type_options") {
-    return {};
-  }
-  return [];
-}
-function collectionValueCount(field, value) {
-  if (Array.isArray(value)) {
-    return value.length;
-  }
-  if (field === "type_options" && value && typeof value === "object") {
-    return Object.keys(value).length;
-  }
-  return 0;
-}
-function buildCollectionMutationPlans(row, update) {
-  const changes = [];
-  for (const definition of COLLECTION_MUTATION_PLAN_DEFINITIONS) {
-    const addValues = update[definition.addKey];
-    const removeValues = definition.removeKey ? update[definition.removeKey] : void 0;
-    const addCount = Array.isArray(addValues) ? addValues.length : 0;
-    const removeCount = Array.isArray(removeValues) ? removeValues.length : 0;
-    const clear = update[definition.clearKey] === true;
-    const replace = definition.replaceKey ? update[definition.replaceKey] === true : false;
-    if (!clear && !replace && addCount === 0 && removeCount === 0) {
-      continue;
-    }
-    const before = normalizeCollectionBeforeValue(definition.field, row[definition.field]);
-    const beforeCount = collectionValueCount(definition.field, before);
-    const operation = replace ? "replace" : clear ? "clear_or_reset" : removeCount > 0 ? "merge_remove" : "append";
-    changes.push({
-      field: definition.field,
-      before,
-      after: {
-        operation,
-        clear,
-        replace,
-        add_count: addCount,
-        remove_count: removeCount,
-        before_count: beforeCount
-      }
-    });
-  }
-  return changes;
-}
-function normalizeExistingTags(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.filter((tag) => typeof tag === "string");
-}
-function buildTagMutationPlan(row, update) {
-  const hasReplace = update.tags !== void 0;
-  const hasAdd = Array.isArray(update.addTags) && update.addTags.length > 0;
-  const hasRemove = Array.isArray(update.removeTags) && update.removeTags.length > 0;
-  if (!hasReplace && !hasAdd && !hasRemove) {
-    return void 0;
-  }
-  const existing = normalizeExistingTags(row.tags);
-  const baseTags = hasReplace ? parseTags(update.tags) : existing;
-  const withAdditions = mergeAdditiveTags(baseTags, update.addTags);
-  const after = applyTagRemovals(withAdditions, update.removeTags).slice().sort((a, b) => a.localeCompare(b));
-  const before = existing.slice().sort((a, b) => a.localeCompare(b));
-  if (areValuesEqual(before, after)) {
-    return void 0;
-  }
-  return { field: "tags", before: existing, after };
-}
-function buildPlannedItemDiff(item, update = {}, runtimeFieldRegistry) {
-  const safeUpdate = update;
-  const row = toItemRecord(item);
-  const changes = [];
-  const tagPlan = buildTagMutationPlan(row, safeUpdate);
-  if (tagPlan) {
-    changes.push(tagPlan);
-  }
-  for (const [optionKey, itemKey] of Object.entries(UPDATE_OPTION_TO_ITEM_KEY)) {
-    const candidate = safeUpdate[optionKey];
-    if (candidate === void 0) {
-      continue;
-    }
-    const before = row[itemKey];
-    const after = toComparablePreviewValue(optionKey, candidate);
-    if (areValuesEqual(before, after)) {
-      continue;
-    }
-    changes.push({
-      field: itemKey,
-      before,
-      after
-    });
-  }
-  changes.push(...buildCollectionMutationPlans(row, safeUpdate));
-  const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(safeUpdate, runtimeFieldRegistry, ["update_many"]);
-  for (const [fieldKey, fieldValue] of Object.entries(runtimeFieldUpdates)) {
-    const before = row[fieldKey];
-    if (areValuesEqual(before, fieldValue)) {
-      continue;
-    }
-    changes.push({
-      field: fieldKey,
-      before,
-      after: fieldValue
-    });
-  }
-  if (safeUpdate.unset && safeUpdate.unset.length > 0) {
-    for (const rawUnsetField of safeUpdate.unset) {
-      const field = normalizeUnsetField(rawUnsetField);
-      const before = row[field];
-      if (before === void 0) {
-        continue;
-      }
-      changes.push({
-        field,
-        before,
-        after: null
-      });
-    }
-  }
-  return {
-    id: item.id,
-    changes
-  };
-}
-function normalizeStatusFilter(value, statusRegistry) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const normalized = normalizeStatusInput(value, statusRegistry);
-  if (!normalized) {
-    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
-    throw new PmCliError(`Invalid --filter-status value "${value}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
-  }
-  return normalized;
-}
-function rejectBlankIdsFilter(list) {
-  if (list?.ids != null && String(list.ids).trim().length === 0) {
-    throw new PmCliError("--ids requires at least one non-empty item ID", EXIT_CODE.USAGE);
-  }
-}
-function assertPlannedUpdateValuesValid(update, settings, statusRegistry, pmRoot) {
-  if (update.priority !== void 0) {
-    resolvePriority(update.priority);
-  }
-  if (update.type !== void 0) {
-    const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-    if (!resolveTypeName(update.type, typeRegistry)) {
-      throw new PmCliError(buildInvalidTypeError(update.type, typeRegistry.types, resolveItemTypesFilePath(pmRoot, settings.schema)), EXIT_CODE.USAGE);
-    }
-  }
-  if (update.status !== void 0 && !normalizeStatusInput(update.status, statusRegistry)) {
-    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
-    throw new PmCliError(`Invalid --status value "${update.status}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
-  }
-  if (update.deadline !== void 0) {
-    resolveIsoOrRelative(update.deadline, /* @__PURE__ */ new Date(), "deadline");
-  }
-}
-async function runUpdateManyRollback(params) {
-  const checkpoint = await loadMutationCheckpoint(params.pmRoot, UPDATE_MANY_CHECKPOINT_SUBDIR, params.rollbackId, UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION);
-  const restoreMessage = params.options.update?.message ?? `Rollback update-many checkpoint ${checkpoint.id}`;
-  const rollback = await restoreCheckpointItems(checkpoint.items, (id, targetUpdatedAt) => runRestore(id, targetUpdatedAt, {
-    author: params.options.update?.author,
-    message: restoreMessage,
-    force: params.options.update?.force ?? true
-  }, params.global));
-  return {
-    mode: "rollback",
-    matched_count: checkpoint.items.length,
-    dry_run: false,
-    rollback_checkpoint_id: checkpoint.id,
-    checkpoint: {
-      id: checkpoint.id,
-      created_at: checkpoint.created_at,
-      path: checkpoint.path,
-      rollback_command: `pm update-many --rollback ${checkpoint.id}`
-    },
-    restored_count: rollback.restored_ids.length,
-    failed_count: rollback.failed_count,
-    rows: rollback.rows,
-    ids: rollback.restored_ids
-  };
-}
-async function writeUpdateManyCheckpoint(params) {
-  const checkpointPayload = {
-    schema_version: UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION,
-    id: params.checkpointId,
-    created_at: params.nowValue,
-    author: resolveAuthor(params.options.update?.author, "unknown"),
-    status_filter: params.statusFilter ?? null,
-    list_filters: params.filters,
-    update_options: params.updateSummary,
-    items: params.checkpointItems
-  };
-  const checkpointPath = await writeMutationCheckpoint(params.pmRoot, UPDATE_MANY_CHECKPOINT_SUBDIR, params.checkpointId, checkpointPayload);
-  return {
-    id: params.checkpointId,
-    created_at: params.nowValue,
-    path: checkpointPath,
-    rollback_command: `pm update-many --rollback ${params.checkpointId}`
-  };
-}
-async function runUpdateMany(options, global2) {
-  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-  const settings = await readSettings(pmRoot);
-  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
-  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
-  const dryRun = options.dryRun === true;
-  const rollbackId = typeof options.rollback === "string" ? options.rollback : void 0;
-  const updateSummary = sanitizeUpdateOptionsForSummary(options.update);
-  rejectBlankIdsFilter(options.list);
-  if (rollbackId) {
-    if (dryRun) {
-      throw new PmCliError("--dry-run cannot be combined with --rollback", EXIT_CODE.USAGE);
-    }
-    if (hasListFilters(options.list, options.status)) {
-      throw new PmCliError("Rollback mode does not accept filter options", EXIT_CODE.USAGE);
-    }
-    if (Object.keys(updateSummary).length > 0) {
-      throw new PmCliError("Rollback mode does not accept update mutation flags", EXIT_CODE.USAGE);
-    }
-    return runUpdateManyRollback({ pmRoot, rollbackId, options, global: global2 });
-  }
-  if (!hasAnyUpdateMutationInput(options.update)) {
-    throw new PmCliError(`No update-many mutation flags provided. Add at least one mutation flag (for example: ${UPDATE_MANY_MUTATION_FLAG_GUIDANCE}).`, EXIT_CODE.USAGE);
-  }
-  assertPlannedUpdateValuesValid(options.update, settings, statusRegistry, pmRoot);
-  const statusFilter = normalizeStatusFilter(options.status, statusRegistry);
-  const listed = await runList(statusFilter, { ...options.list, includeBody: true }, global2);
-  const planned = listed.items.map((item) => buildPlannedItemDiff(item, options.update, runtimeFieldRegistry));
-  const actionable = planned.filter((row) => row.changes.length > 0);
-  if (dryRun) {
-    return {
-      mode: "dry_run",
-      matched_count: listed.items.length,
-      dry_run: true,
-      filters: listed.filters,
-      planned_update_options: updateSummary,
-      item_plans: planned,
-      ids: []
-    };
-  }
-  if (actionable.length === 0) {
-    return {
-      mode: "apply",
-      matched_count: listed.items.length,
-      dry_run: false,
-      filters: listed.filters,
-      planned_update_options: updateSummary,
-      updated_count: 0,
-      skipped_count: listed.items.length,
-      failed_count: 0,
-      rows: planned.map((row) => ({
-        id: row.id,
-        status: "skipped"
-      })),
-      ids: []
-    };
-  }
-  const nowValue = nowIso();
-  const checkpointId = createCheckpointId(UPDATE_MANY_CHECKPOINT_SUBDIR, nowValue);
-  const checkpointEnabled = options.checkpoint !== false;
-  const checkpointItems = listed.items.filter((item) => actionable.some((candidate) => candidate.id === item.id)).map((item) => ({
-    id: item.id,
-    target_updated_at: item.updated_at
-  }));
-  let checkpointInfo;
-  if (checkpointEnabled) {
-    checkpointInfo = await writeUpdateManyCheckpoint({
-      pmRoot,
-      checkpointId,
-      nowValue,
-      options,
-      statusFilter,
-      filters: listed.filters,
-      updateSummary,
-      checkpointItems
-    });
-  }
-  const applyRows = [];
-  const updatedIds = [];
-  const updateMessage = options.update.message ?? `update-many apply ${checkpointId}`;
-  const actionableById = new Set(actionable.map((row) => row.id));
-  for (const item of listed.items) {
-    if (!actionableById.has(item.id)) {
-      applyRows.push({ id: item.id, status: "skipped" });
-      continue;
-    }
-    try {
-      const result = await runUpdate(item.id, {
-        ...options.update,
-        message: updateMessage,
-        runtimeFieldCommands: ["update_many"]
-      }, global2);
-      applyRows.push({
-        id: item.id,
-        status: "updated",
-        changed_fields: result.changed_fields,
-        warnings: result.warnings
-      });
-      updatedIds.push(item.id);
-    } catch (error) {
-      applyRows.push({
-        id: item.id,
-        status: "failed",
-        error: toErrorMessage(error)
-      });
-    }
-  }
-  const updatedCount = applyRows.filter((row) => row.status === "updated").length;
-  const skippedCount = applyRows.filter((row) => row.status === "skipped").length;
-  const failedCount = applyRows.filter((row) => row.status === "failed").length;
-  return {
-    mode: "apply",
-    matched_count: listed.items.length,
-    dry_run: false,
-    filters: listed.filters,
-    planned_update_options: updateSummary,
-    ...checkpointInfo ? { checkpoint: checkpointInfo } : {},
-    updated_count: updatedCount,
-    skipped_count: skippedCount,
-    failed_count: failedCount,
-    rows: applyRows,
-    ids: updatedIds
-  };
-}
-var _testOnlyUpdateManyCommand = {
-  assertPlannedUpdateValuesValid,
-  buildCollectionMutationPlans,
-  buildPlannedItemDiff,
-  buildTagMutationPlan,
-  collectionValueCount,
-  hasAnyUpdateMutationInput,
-  hasListFilters,
-  normalizeStatusFilter,
-  normalizeCollectionBeforeValue,
-  normalizeExistingTags,
-  normalizeUnsetField,
-  rejectBlankIdsFilter,
-  sanitizeUpdateOptionsForSummary,
-  toComparablePreviewValue
-};
-export {
-  _testOnlyUpdateManyCommand,
-  runUpdateMany
-};
-//# sourceMappingURL=update-many-DC7X3EWM.js.map