@unbrained/pm-cli 2026.5.14 → 2026.5.24

package/dist/cli/commands/update.js

@@ -1,9 +1,13 @@
+
+!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]="689e9580-d7f6-5b07-be3d-28c381d20260")}catch(e){}}();
 import { pathExists } from "../../core/fs/fs-utils.js";
 import { canonicalizeCommandOptionKey, commandOptionFlagLabel, resolveItemTypeRegistry, resolveCommandOptionPolicyState, resolveTypeDefinition, resolveTypeName, validateTypeOptions, } from "../../core/item/type-registry.js";
 import { normalizeItemId } from "../../core/item/id.js";
+import { buildInvalidTypeError } from "../../core/schema/item-types-file.js";
 import { normalizeParentReferenceValue, validateMissingParentReference, } from "../../core/item/parent-reference-policy.js";
 import { validateSprintOrReleaseValue } from "../../core/item/sprint-release-format.js";
 import { createStdinTokenResolver, parseCsvKv, parseOptionalNumber, parseTags } from "../../core/item/parse.js";
+import { resolvePriority } from "../../core/item/priority.js";
 import { normalizeStatusInput } from "../../core/item/status.js";
 import { collectRuntimeUpdateFieldValues } from "../../core/schema/runtime-field-values.js";
 import { resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, } from "../../core/schema/runtime-schema.js";
@@ -12,11 +16,13 @@ import { PmCliError } from "../../core/shared/errors.js";
 import { resolveIsoOrRelative } from "../../core/shared/time.js";
 import { getActiveExtensionRegistrations } from "../../core/extensions/index.js";
 import { applyRegisteredItemFieldDefaultsAndValidation } from "../../core/extensions/item-fields.js";
-import { locateItem, mutateItem } from "../../core/store/item-store.js";
+import { buildItemNotFoundError, locateItem, mutateItem, readLocatedItem } from "../../core/store/item-store.js";
 import { getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
+import { runClose } from "./close.js";
 import { normalizeRiskInput, normalizeSeverityInput, parseConfidenceInput, parseRegressionInput, } from "./metadata-normalizers.js";
-import { DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, RISK_VALUES, } from "../../types/index.js";
+import { resolveEventEndAt } from "./event-validation-messages.js";
+import { DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, RISK_VALUES, weekdayOrderIndex, } from "../../types/index.js";
 import { parseDocs, parseFiles, parseLogSeed, parseTests } from "./create.js";
 const LEGACY_NONE_TOKENS = new Set(["none", "null"]);
 const UPDATE_UNSET_FIELD_DEFINITIONS = [
@@ -477,7 +483,7 @@ function enforceAllowAuditUpdateScope(options, clearFrontMatterKeys) {
 }
 function ensureEnum(value, allowed, label) {
     if (!allowed.includes(value)) {
-        throw new PmCliError(`Invalid ${label} value "${value}"`, EXIT_CODE.USAGE);
+        throw new PmCliError(`Invalid ${label} value "${value}". Allowed: ${allowed.join(", ")}`, EXIT_CODE.USAGE);
     }
     return value;
 }
@@ -489,16 +495,13 @@ function parseStatus(value, statusRegistry) {
     }
     return normalized;
 }
-function weekdayOrderIndex(value) {
-    return RECURRENCE_WEEKDAY_VALUES.indexOf(value);
-}
 function parseReminderEntries(raw, nowValue) {
     return raw.map((entry) => {
         const kv = parseCsvKv(entry, "--reminder");
-        const atRaw = kv.at?.trim();
-        const textRaw = kv.text?.trim();
+        const atRaw = (kv.at ?? kv.date)?.trim();
+        const textRaw = (kv.text ?? kv.title)?.trim();
         if (!atRaw || !textRaw) {
-            throw new PmCliError("--reminder requires at=<iso|relative> and text=<value>", EXIT_CODE.USAGE);
+            throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
         }
         return {
             at: resolveIsoOrRelative(atRaw, nowValue, "reminder.at"),
@@ -584,10 +587,8 @@ function parseEventEntries(raw, nowValue) {
         }
         const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
         const endRaw = kv.end?.trim();
-        const endAt = endRaw ? resolveIsoOrRelative(endRaw, nowValue, "event.end") : undefined;
-        if (endAt && endAt <= startAt) {
-            throw new PmCliError("--event end must be after start", EXIT_CODE.USAGE);
-        }
+        const durationRaw = kv.duration?.trim();
+        const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, nowValue);
         const titleRaw = kv.title;
         const descriptionRaw = kv.description;
         const locationRaw = kv.location;
@@ -747,6 +748,63 @@ function parseDependencyRemovals(raw, prefix) {
 function dependencyKey(value) {
     return `${value.id}::${value.kind}::${value.source_kind ?? ""}`;
 }
+// pm-kyd6: `--blocked-by` writes the `blocked_by` scalar, but the dependency
+// graph (`pm deps`) is built only from the `dependencies` array. Mirror the
+// behaviour create.ts already has so the metadata and the graph agree: a
+// resolvable blocker also gets a `blocked_by` dependency edge, clearing the
+// scalar removes that edge, and re-pointing it replaces the prior edge.
+function reconcileBlockedByDependency(current, nextBlockedById, nowIsoValue, author) {
+    let next = [...(current ?? [])];
+    let changed = false;
+    const filtered = next.filter((dep) => dep.kind !== "blocked_by" || dep.id === nextBlockedById);
+    if (filtered.length !== next.length) {
+        next = filtered;
+        changed = true;
+    }
+    if (nextBlockedById && !next.some((dep) => dep.kind === "blocked_by" && dep.id === nextBlockedById)) {
+        next.push({ id: nextBlockedById, kind: "blocked_by", created_at: nowIsoValue, author });
+        changed = true;
+    }
+    if (!changed) {
+        return { dependencies: current, changed: false };
+    }
+    return { dependencies: next.length > 0 ? next : undefined, changed: true };
+}
+// pm-kyd6: resolve the --blocked-by target before the synchronous mutate
+// callback so a real blocker can also become a `blocked_by` dependency edge.
+// `id` is set when the target resolves; `unresolved` carries the raw value when
+// --blocked-by points at an item that does not exist (the scalar is still set,
+// mirroring create.ts and the never-block missing-parent behaviour, but the
+// caller surfaces a warning so the metadata/graph mismatch is visible).
+async function resolveBlockedByDependencyTarget(blockedByOption, blockedByCleared, pmRoot, idPrefix, itemFormat, typeToFolder) {
+    if (blockedByOption === undefined || blockedByCleared) {
+        return {};
+    }
+    const blockedByValue = blockedByOption.trim();
+    if (blockedByValue.length === 0) {
+        return {};
+    }
+    const located = await locateItem(pmRoot, normalizeItemId(blockedByValue, idPrefix), idPrefix, itemFormat, typeToFolder);
+    return located ? { id: located.id } : { unresolved: blockedByValue };
+}
+// pm-kyd6: apply the reconciled blocked_by dependency edge to the item metadata
+// and record the `dependencies` change. Kept out of the mutate callback so the
+// large runUpdate function stays under the static-quality complexity budget.
+function applyBlockedByDependencyEdge(metadata, resolvedBlockedById, nowIsoValue, author, changedFields) {
+    const reconciled = reconcileBlockedByDependency(metadata.dependencies, resolvedBlockedById, nowIsoValue, author);
+    if (!reconciled.changed) {
+        return;
+    }
+    if (reconciled.dependencies === undefined) {
+        delete metadata.dependencies;
+    }
+    else {
+        metadata.dependencies = reconciled.dependencies;
+    }
+    if (!changedFields.includes("dependencies")) {
+        changedFields.push("dependencies");
+    }
+}
 function fileKey(value) {
     return `${value.path}::${value.scope}`;
 }
@@ -769,11 +827,7 @@ function matchesDependencySelector(value, selector) {
     return true;
 }
 function ensurePriority(raw) {
-    const parsed = parseOptionalNumber(raw, "priority (expected 0..4: 0=critical, 1=high, 2=medium, 3=low, 4=minimal)");
-    if (![0, 1, 2, 3, 4].includes(parsed)) {
-        throw new PmCliError("Priority must be 0..4 (0=critical, 1=high, 2=medium, 3=low, 4=minimal)", EXIT_CODE.USAGE);
-    }
-    return parsed;
+    return resolvePriority(raw);
 }
 function normalizeUpdatePolicyOptionKey(raw, typeName) {
     const canonical = canonicalizeCommandOptionKey("update", raw);
@@ -1131,76 +1185,132 @@ export async function runUpdate(id, options, global) {
             parentReferenceWarnings.push(...validateMissingParentReference(normalizedParentId, parentReferencePolicy).warnings);
         }
     }
-    const changedFlags = [
-        options.title !== undefined,
-        options.description !== undefined,
-        options.body !== undefined,
-        options.status !== undefined,
-        options.closeReason !== undefined,
-        options.priority !== undefined,
-        options.type !== undefined,
-        options.tags !== undefined,
-        options.deadline !== undefined,
-        options.estimatedMinutes !== undefined,
-        options.acceptanceCriteria !== undefined,
-        options.definitionOfReady !== undefined,
-        options.order !== undefined,
-        options.rank !== undefined,
-        options.goal !== undefined,
-        options.objective !== undefined,
-        options.value !== undefined,
-        options.impact !== undefined,
-        options.outcome !== undefined,
-        options.whyNow !== undefined,
-        options.assignee !== undefined,
-        options.parent !== undefined,
-        options.reviewer !== undefined,
-        options.risk !== undefined,
-        options.confidence !== undefined,
-        options.sprint !== undefined,
-        options.release !== undefined,
-        options.blockedBy !== undefined,
-        options.blockedReason !== undefined,
-        options.unblockNote !== undefined,
-        options.reporter !== undefined,
-        options.severity !== undefined,
-        options.environment !== undefined,
-        options.reproSteps !== undefined,
-        options.resolution !== undefined,
-        options.expectedResult !== undefined,
-        options.actualResult !== undefined,
-        options.affectedVersion !== undefined,
-        options.fixedVersion !== undefined,
-        options.component !== undefined,
-        options.regression !== undefined,
-        options.customerImpact !== undefined,
-        options.dep !== undefined,
-        options.depRemove !== undefined,
-        options.replaceDeps === true,
-        options.comment !== undefined,
-        options.note !== undefined,
-        options.learning !== undefined,
-        options.file !== undefined,
-        options.test !== undefined,
-        options.replaceTests === true,
-        options.doc !== undefined,
-        options.reminder !== undefined,
-        options.event !== undefined,
-        options.typeOption !== undefined,
-        options.unset !== undefined && options.unset.length > 0,
-        options.clearDeps === true,
-        options.clearComments === true,
-        options.clearNotes === true,
-        options.clearLearnings === true,
-        options.clearFiles === true,
-        options.clearTests === true,
-        options.clearDocs === true,
-        options.clearReminders === true,
-        options.clearEvents === true,
-        options.clearTypeOptions === true,
-    ].some(Boolean);
+    // pm-kyd6: resolve the --blocked-by target up front (async) so the sync
+    // mutate callback can mirror create.ts and add a `blocked_by` dependency edge.
+    const blockedByResolution = await resolveBlockedByDependencyTarget(options.blockedBy, clearFrontMatterKeys.has("blocked_by"), pmRoot, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+    const resolvedBlockedByDependencyId = blockedByResolution.id;
+    if (blockedByResolution.unresolved !== undefined) {
+        parentReferenceWarnings.push(`blocked_by_unresolved:${blockedByResolution.unresolved}`);
+    }
+    const fieldFlags = {
+        title: options.title !== undefined,
+        description: options.description !== undefined,
+        body: options.body !== undefined,
+        status: options.status !== undefined,
+        closeReason: options.closeReason !== undefined,
+        priority: options.priority !== undefined,
+        type: options.type !== undefined,
+        tags: options.tags !== undefined,
+        deadline: options.deadline !== undefined,
+        estimatedMinutes: options.estimatedMinutes !== undefined,
+        acceptanceCriteria: options.acceptanceCriteria !== undefined,
+        definitionOfReady: options.definitionOfReady !== undefined,
+        order: options.order !== undefined,
+        rank: options.rank !== undefined,
+        goal: options.goal !== undefined,
+        objective: options.objective !== undefined,
+        value: options.value !== undefined,
+        impact: options.impact !== undefined,
+        outcome: options.outcome !== undefined,
+        whyNow: options.whyNow !== undefined,
+        assignee: options.assignee !== undefined,
+        parent: options.parent !== undefined,
+        reviewer: options.reviewer !== undefined,
+        risk: options.risk !== undefined,
+        confidence: options.confidence !== undefined,
+        sprint: options.sprint !== undefined,
+        release: options.release !== undefined,
+        blockedBy: options.blockedBy !== undefined,
+        blockedReason: options.blockedReason !== undefined,
+        unblockNote: options.unblockNote !== undefined,
+        reporter: options.reporter !== undefined,
+        severity: options.severity !== undefined,
+        environment: options.environment !== undefined,
+        reproSteps: options.reproSteps !== undefined,
+        resolution: options.resolution !== undefined,
+        expectedResult: options.expectedResult !== undefined,
+        actualResult: options.actualResult !== undefined,
+        affectedVersion: options.affectedVersion !== undefined,
+        fixedVersion: options.fixedVersion !== undefined,
+        component: options.component !== undefined,
+        regression: options.regression !== undefined,
+        customerImpact: options.customerImpact !== undefined,
+        dep: options.dep !== undefined,
+        depRemove: options.depRemove !== undefined,
+        replaceDeps: options.replaceDeps === true,
+        comment: options.comment !== undefined,
+        note: options.note !== undefined,
+        learning: options.learning !== undefined,
+        file: options.file !== undefined,
+        test: options.test !== undefined,
+        replaceTests: options.replaceTests === true,
+        doc: options.doc !== undefined,
+        reminder: options.reminder !== undefined,
+        event: options.event !== undefined,
+        typeOption: options.typeOption !== undefined,
+        unset: options.unset !== undefined && options.unset.length > 0,
+        clearDeps: options.clearDeps === true,
+        clearComments: options.clearComments === true,
+        clearNotes: options.clearNotes === true,
+        clearLearnings: options.clearLearnings === true,
+        clearFiles: options.clearFiles === true,
+        clearTests: options.clearTests === true,
+        clearDocs: options.clearDocs === true,
+        clearReminders: options.clearReminders === true,
+        clearEvents: options.clearEvents === true,
+        clearTypeOptions: options.clearTypeOptions === true,
+    };
+    const changedFlags = Object.values(fieldFlags).some(Boolean);
     if (!changedFlags) {
-        throw new PmCliError("No update flags provided", EXIT_CODE.USAGE);
+        const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+        if (!located) {
+            throw await buildItemNotFoundError(pmRoot, id, settings.id_prefix, typeRegistry.type_to_folder);
+        }
+        const { document } = await readLocatedItem(located, { schema: settings.schema });
+        return {
+            item: document.metadata,
+            changed_fields: [],
+            warnings: ["noop_no_update_fields"],
+        };
+    }
+    // `pm update --status <close_status>` always routes to the auditable close
+    // workflow so agents are never blocked by close-through-update errors. Any
+    // other field updates in the same call are applied first, then the item is
+    // closed with the supplied --close-reason (or a derived default when omitted).
+    if (fieldFlags.status) {
+        const targetStatus = normalizeStatusInput(options.status, statusRegistry);
+        if (targetStatus === statusRegistry.close_status) {
+            const otherFieldKeys = Object.entries(fieldFlags)
+                .filter(([key, value]) => value && key !== "status" && key !== "closeReason")
+                .map(([key]) => key);
+            const routeWarnings = [];
+            let preChangedFields = [];
+            if (otherFieldKeys.length > 0) {
+                const preUpdate = await runUpdate(id, { ...options, status: undefined, closeReason: undefined, message: undefined }, global);
+                preChangedFields = preUpdate.changed_fields;
+                routeWarnings.push(...preUpdate.warnings);
+            }
+            const explicitReason = typeof options.closeReason === "string" ? options.closeReason.trim() : "";
+            const fallbackMessage = typeof options.message === "string" ? options.message.trim() : "";
+            const closeReason = explicitReason || fallbackMessage || "Closed via pm update";
+            // Only flag a defaulted reason when neither --close-reason nor --message
+            // supplied any text and we had to invent the generic placeholder.
+            const reasonDefaulted = explicitReason.length === 0 && fallbackMessage.length === 0;
+            const closeResult = await runClose(id, closeReason, {
+                author: options.author,
+                message: options.message,
+                force: options.force,
+            }, global);
+            const warnings = [...routeWarnings, ...closeResult.warnings, "auto_routed_from_update_to_close"];
+            if (reasonDefaulted) {
+                warnings.push("close_reason_defaulted");
+            }
+            return {
+                item: closeResult.item,
+                changed_fields: [...preChangedFields, ...closeResult.changed_fields],
+                warnings,
+            };
+        }
     }
     if (options.order !== undefined && options.rank !== undefined && options.order !== options.rank) {
         throw new PmCliError("--order and --rank must match when both are provided", EXIT_CODE.USAGE);
@@ -1234,21 +1344,9 @@ export async function runUpdate(id, options, global) {
             const previousStatus = document.metadata.status;
             const previousStatusNormalized = normalizeStatusInput(previousStatus, statusRegistry) ?? previousStatus;
             if (options.status !== undefined) {
+                // Close-status routing (with reason + audit) is handled before mutateItem
+                // by the close gate above, so only non-close transitions reach this path.
                 const status = parseStatus(options.status, statusRegistry);
-                if (status === statusRegistry.close_status) {
-                    throw new PmCliError(`Invalid --status value "${statusRegistry.close_status}". Use "pm close <ID> <TEXT>" to close an item.`, EXIT_CODE.USAGE, {
-                        code: "close_through_update",
-                        why: "Closing requires a close reason and optional validation checks that pm update cannot enforce. Use pm close for auditable close workflows.",
-                        examples: [
-                            `pm close ${id} "All acceptance criteria met" --author "${author}" --message "Close: verified"`,
-                            `pm close ${id} "Resolved" --validate-close warn --author "${author}"`,
-                        ],
-                        nextSteps: [
-                            'Use "pm close <ID> <reason>" to close with required close reason and optional --validate-close.',
-                            'To cancel instead, use "pm update <ID> --status canceled".',
-                        ],
-                    });
-                }
                 document.metadata.status = status;
                 if (status === statusRegistry.canceled_status) {
                     delete document.metadata.assignee;
@@ -1282,7 +1380,7 @@ export async function runUpdate(id, options, global) {
             if (options.type !== undefined) {
                 const resolvedTypeName = resolveTypeName(options.type, typeRegistry);
                 if (!resolvedTypeName) {
-                    throw new PmCliError(`Invalid type value "${options.type}". Allowed: ${typeRegistry.types.join(", ")}`, EXIT_CODE.USAGE);
+                    throw new PmCliError(buildInvalidTypeError(options.type, typeRegistry.types), EXIT_CODE.USAGE);
                 }
                 document.metadata.type = resolvedTypeName;
                 activeTypeName = resolvedTypeName;
@@ -1622,6 +1720,8 @@ export async function runUpdate(id, options, global) {
                     document.metadata.blocked_by = options.blockedBy.trim();
                 }
                 changedFields.push("blocked_by");
+                // pm-kyd6: keep the dependency graph in sync with the blocked_by scalar.
+                applyBlockedByDependencyEdge(document.metadata, resolvedBlockedByDependencyId, nowIso, author, changedFields);
             }
             if (options.blockedReason !== undefined || clearFrontMatterKeys.has("blocked_reason")) {
                 if (clearFrontMatterKeys.has("blocked_reason")) {
@@ -1804,4 +1904,5 @@ export async function runUpdate(id, options, global) {
         ...(options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? { audit_update: true } : {}),
     };
 }
-//# sourceMappingURL=update.js.map
+//# sourceMappingURL=update.js.map
+//# debugId=689e9580-d7f6-5b07-be3d-28c381d20260