@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,655 @@
+
+!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]="56c62d91-fa7e-53d1-93a4-55bceb50e136")}catch(e){}}();
+import {
+  runUpdate
+} from "./chunk-ZZD4J5XY.js";
+import {
+  resolvePriority
+} from "./chunk-TULGS6X6.js";
+import {
+  applyTagRemovals,
+  mergeAdditiveTags,
+  parseTags
+} from "./chunk-IWVU4C2F.js";
+import {
+  createCheckpointId,
+  loadMutationCheckpoint,
+  restoreCheckpointItems,
+  writeMutationCheckpoint
+} from "./chunk-SMB7RV23.js";
+import {
+  runRestore
+} from "./chunk-YN7Y6DQZ.js";
+import {
+  resolveAuthor
+} from "./chunk-T5RRNDA7.js";
+import {
+  hasListFilters
+} from "./chunk-VY3VQ22F.js";
+import {
+  runList
+} from "./chunk-3VHSI5FL.js";
+import {
+  toItemRecord
+} from "./chunk-ENGQOEUY.js";
+import {
+  collectRuntimeUpdateFieldValues,
+  normalizeStatusInput
+} from "./chunk-G24G7ZAV.js";
+import {
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  stableValueEquals
+} from "./chunk-E3SZTQ4K.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-KUOOJR35.js";
+import {
+  EXIT_CODE,
+  getSettingsPath,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolveItemTypesFilePath,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  resolveTypeName,
+  toErrorMessage
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/update-many.js
+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, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.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 });
+  }
+  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 }, global);
+  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"]
+      }, global);
+      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 {
+  runUpdateMany,
+  _testOnlyUpdateManyCommand
+};
+//# sourceMappingURL=chunk-EBRZZ54H.js.map
+
+//# debugId=56c62d91-fa7e-53d1-93a4-55bceb50e136