@unbrained/pm-cli 2026.5.10 → 2026.5.11

package/dist/cli/commands/update.js

@@ -15,7 +15,8 @@ import { applyRegisteredItemFieldDefaultsAndValidation } from "../../core/extens
 import { locateItem, mutateItem } from "../../core/store/item-store.js";
 import { getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
-import { CONFIDENCE_TEXT_VALUES, DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, RISK_VALUES, } from "../../types/index.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 { parseDocs, parseFiles, parseLogSeed, parseTests } from "./create.js";
 const LEGACY_NONE_TOKENS = new Set(["none", "null"]);
 const UPDATE_UNSET_FIELD_DEFINITIONS = [
@@ -187,6 +188,61 @@ function assertNoLegacyNoneTokens(values, flag, replacementHint) {
     const suffix = replacementHint ? ` ${replacementHint}` : "";
     throw new PmCliError(`${flag} no longer accepts "none" or "null".${suffix}`.trim(), EXIT_CODE.USAGE);
 }
+const UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS = [
+    { optionKey: "dep", clearFlagKey: "clearDeps", valueFlag: "--dep", clearFlag: "--clear-deps", disableReplaceFlagKey: "replaceDeps" },
+    { optionKey: "comment", clearFlagKey: "clearComments", valueFlag: "--comment", clearFlag: "--clear-comments" },
+    { optionKey: "note", clearFlagKey: "clearNotes", valueFlag: "--note", clearFlag: "--clear-notes" },
+    { optionKey: "learning", clearFlagKey: "clearLearnings", valueFlag: "--learning", clearFlag: "--clear-learnings" },
+    { optionKey: "file", clearFlagKey: "clearFiles", valueFlag: "--file", clearFlag: "--clear-files" },
+    { optionKey: "test", clearFlagKey: "clearTests", valueFlag: "--test", clearFlag: "--clear-tests", disableReplaceFlagKey: "replaceTests" },
+    { optionKey: "doc", clearFlagKey: "clearDocs", valueFlag: "--doc", clearFlag: "--clear-docs" },
+    { optionKey: "reminder", clearFlagKey: "clearReminders", valueFlag: "--reminder", clearFlag: "--clear-reminders" },
+    { optionKey: "event", clearFlagKey: "clearEvents", valueFlag: "--event", clearFlag: "--clear-events" },
+    { optionKey: "typeOption", clearFlagKey: "clearTypeOptions", valueFlag: "--type-option", clearFlag: "--clear-type-options" },
+];
+function normalizeLegacyNoneUpdateOptions(options) {
+    const normalized = {
+        ...options,
+        unset: options.unset ? [...options.unset] : undefined,
+    };
+    const appendUnsetTarget = (value) => {
+        const current = normalized.unset ? [...normalized.unset] : [];
+        if (!current.includes(value)) {
+            current.push(value);
+        }
+        normalized.unset = current;
+    };
+    const scalarOptionKeys = new Set([...UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.keys(), "rank"]);
+    for (const optionKey of scalarOptionKeys) {
+        const candidate = normalized[optionKey];
+        if (typeof candidate !== "string" || !isLegacyNoneToken(candidate)) {
+            continue;
+        }
+        const canonicalUnset = optionKey === "rank" ? "order" : (UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey) ?? optionKey);
+        appendUnsetTarget(canonicalUnset);
+        normalized[optionKey] = undefined;
+    }
+    for (const definition of UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS) {
+        const entries = normalized[definition.optionKey];
+        if (!Array.isArray(entries) || entries.length === 0) {
+            continue;
+        }
+        const hasLegacy = entries.some((entry) => isLegacyNoneToken(entry));
+        if (!hasLegacy) {
+            continue;
+        }
+        const concreteEntries = entries.filter((entry) => !isLegacyNoneToken(entry));
+        if (concreteEntries.length > 0) {
+            throw new PmCliError(`Cannot mix legacy clear token "none"/"null" with concrete ${definition.valueFlag} entries. Use ${definition.clearFlag} to clear or provide explicit entries.`, EXIT_CODE.USAGE);
+        }
+        normalized[definition.optionKey] = undefined;
+        normalized[definition.clearFlagKey] = true;
+        if (definition.disableReplaceFlagKey) {
+            normalized[definition.disableReplaceFlagKey] = false;
+        }
+    }
+    return normalized;
+}
 function resolveRuntimeUnsetDefinition(token, runtimeFieldRegistry) {
     if (!runtimeFieldRegistry) {
         return undefined;
@@ -433,38 +489,6 @@ function parseStatus(value, statusRegistry) {
     }
     return normalized;
 }
-function normalizeRiskInput(value) {
-    const trimmed = value.trim();
-    return trimmed.toLowerCase() === "med" ? "medium" : trimmed;
-}
-function normalizeSeverityInput(value) {
-    const trimmed = value.trim();
-    return trimmed.toLowerCase() === "med" ? "medium" : trimmed;
-}
-function parseConfidenceInput(value) {
-    const trimmed = value.trim().toLowerCase();
-    if (trimmed === "med") {
-        return "medium";
-    }
-    if (CONFIDENCE_TEXT_VALUES.includes(trimmed)) {
-        return trimmed;
-    }
-    const parsed = parseOptionalNumber(value, "confidence");
-    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) {
-        throw new PmCliError("Confidence must be an integer 0..100 or one of low|med|medium|high", EXIT_CODE.USAGE);
-    }
-    return parsed;
-}
-function parseRegressionInput(value) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "true" || normalized === "1") {
-        return true;
-    }
-    if (normalized === "false" || normalized === "0") {
-        return false;
-    }
-    throw new PmCliError("Regression must be one of true|false|1|0", EXIT_CODE.USAGE);
-}
 function weekdayOrderIndex(value) {
     return RECURRENCE_WEEKDAY_VALUES.indexOf(value);
 }
@@ -554,9 +578,9 @@ function parseRecurrenceRule(kv, startAt, nowValue) {
 function parseEventEntries(raw, nowValue) {
     return raw.map((entry) => {
         const kv = parseCsvKv(entry, "--event");
-        const startRaw = kv.start?.trim();
+        const startRaw = (kv.start ?? kv.date)?.trim();
         if (!startRaw) {
-            throw new PmCliError("--event requires start=<iso|relative>", EXIT_CODE.USAGE);
+            throw new PmCliError("--event requires start=<iso|relative> or date=<iso|relative>", EXIT_CODE.USAGE);
         }
         const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
         const endRaw = kv.end?.trim();
@@ -652,17 +676,24 @@ function parseOptionalDependencyString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+function looksLikeStructuredDependencyEntry(raw) {
+    if (raw.startsWith("```") || raw.includes("\n")) {
+        return true;
+    }
+    return /^(?:[-*+]\s+)?(?:id|kind|author|created_at|source_kind)\s*[:=]/i.test(raw);
+}
 function parseDependencyAdditions(raw, prefix, nowIso) {
     if (!raw) {
         return { additions: [] };
     }
     assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
     const additions = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--dep");
+        const trimmedEntry = entry.trim();
+        const kv = looksLikeStructuredDependencyEntry(trimmedEntry) ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
         const id = kv.id?.trim();
         const kind = kv.kind?.trim();
         if (!id || !kind) {
-            throw new PmCliError("--dep requires id and kind", EXIT_CODE.USAGE);
+            throw new PmCliError("--dep requires id and kind, or a bare item id to add a related dependency", EXIT_CODE.USAGE);
         }
         if (id.toLowerCase() === "undefined") {
             throw new PmCliError(`--dep id must not use placeholder token "${id}". Use --clear-deps to clear dependencies.`, EXIT_CODE.USAGE);
@@ -857,7 +888,7 @@ function enforceUpdateOptionsByType(typeName, options, typeRegistry) {
 }
 export async function runUpdate(id, options, global) {
     const stdinResolver = createStdinTokenResolver();
-    options = {
+    options = normalizeLegacyNoneUpdateOptions({
         ...options,
         body: await stdinResolver.resolveValue(options.body, "--body"),
         dep: await stdinResolver.resolveList(options.dep, "--dep"),
@@ -871,7 +902,7 @@ export async function runUpdate(id, options, global) {
         reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
         event: await stdinResolver.resolveList(options.event, "--event"),
         typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
-    };
+    });
     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);