@unbrained/pm-cli 2026.5.10 → 2026.5.11

package/dist/cli/commands/create.js

@@ -19,7 +19,8 @@ import { locateItem } from "../../core/store/item-store.js";
 import { getHistoryPath, getItemPath, getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
 import { loadCreateTemplateOptions } from "./templates.js";
-import { CONFIDENCE_TEXT_VALUES, DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, RISK_VALUES, SCOPE_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, SCOPE_VALUES, } from "../../types/index.js";
 const CREATE_MODE_VALUES = ["strict", "progressive"];
 const SCHEDULE_CREATE_PRESET_VALUES = ["lightweight"];
 const SCHEDULE_CREATE_PRESET_TYPES = new Set(["Reminder", "Meeting", "Event"]);
@@ -171,38 +172,6 @@ function parseStatusValue(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 parseCreatedAt(value, currentIso) {
     if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
         return currentIso;
@@ -237,6 +206,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 CREATE_LEGACY_NONE_COLLECTION_NORMALIZERS = [
+    { optionKey: "dep", clearFlagKey: "clearDeps", valueFlag: "--dep", clearFlag: "--clear-deps" },
+    { 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" },
+    { 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 normalizeLegacyNoneCreateOptions(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;
+    };
+    if (isLegacyNoneToken(normalized.template)) {
+        normalized.template = undefined;
+    }
+    const scalarOptionKeys = new Set([...CREATE_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" : (CREATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey) ?? optionKey);
+        appendUnsetTarget(canonicalUnset);
+        normalized[optionKey] = undefined;
+    }
+    for (const definition of CREATE_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;
+    }
+    return normalized;
+}
 function parseOptionalString(value) {
     if (value === undefined)
         return undefined;
@@ -299,11 +323,14 @@ function parseDependencies(raw, nowValue, prefix) {
         return { values: undefined, explicitEmpty: false };
     assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
     const values = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--dep");
+        const trimmedEntry = entry.trim();
+        const kv = looksLikeStructuredEntry(trimmedEntry, ["id", "kind", "author", "created_at"])
+            ? parseCsvKv(entry, "--dep")
+            : { id: trimmedEntry, kind: "related" };
         const id = parseOptionalString(kv.id);
         const kind = parseOptionalString(kv.kind);
         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 create a related dependency", EXIT_CODE.USAGE);
         }
         if (id.trim().toLowerCase() === "undefined") {
             throw new PmCliError(`--dep id must not use placeholder token "${id}". Use --clear-deps to clear dependencies.`, EXIT_CODE.USAGE);
@@ -317,6 +344,13 @@ function parseDependencies(raw, nowValue, prefix) {
     });
     return { values, explicitEmpty: false };
 }
+function looksLikeStructuredEntry(raw, keys) {
+    if (raw.startsWith("```") || raw.includes("\n")) {
+        return true;
+    }
+    const keyPattern = keys.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    return new RegExp(`^(?:[-*+]\\s+)?(?:${keyPattern})\\s*[:=]`, "i").test(raw);
+}
 export function parseLogSeed(optionName, raw, nowValue, fallbackAuthor) {
     if (!raw || raw.length === 0)
         return { values: undefined, explicitEmpty: false };
@@ -343,17 +377,18 @@ export function parseLogSeed(optionName, raw, nowValue, fallbackAuthor) {
             kv = parseCsvKv(entry, optionName);
         }
         catch (error) {
-            if (optionName === "--comment") {
+            if (optionName === "--comment" || optionName === "--note" || optionName === "--learning") {
                 return buildPlainTextCommentSeed();
             }
             throw error;
         }
         const unsupportedKeys = Object.keys(kv).filter((key) => !LOG_SEED_ALLOWED_KEYS.has(key));
         if (unsupportedKeys.length > 0) {
-            if (optionName === "--comment" && !trimmedEntry.includes(",") && !trimmedEntry.includes("\n")) {
-                return buildPlainTextCommentSeed();
-            }
-            throw new PmCliError(buildInvalidLogSeedKeysMessage(optionName, unsupportedKeys), EXIT_CODE.USAGE);
+            return {
+                created_at: parseCreatedAt(kv.created_at, nowValue),
+                author: parseOptionalString(kv.author) ?? fallbackAuthor,
+                text: trimmedEntry,
+            };
         }
         const text = kv.text ?? "";
         if (text === "") {
@@ -372,9 +407,12 @@ export function parseFiles(raw) {
         return { values: undefined, explicitEmpty: false };
     assertNoLegacyNoneTokens(raw, "--file", "Use --clear-files to clear linked files.");
     const values = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--file");
+        const trimmedEntry = entry.trim();
+        const kv = looksLikeStructuredEntry(trimmedEntry, ["path", "scope", "note"])
+            ? parseCsvKv(entry, "--file")
+            : { path: trimmedEntry };
         if (!kv.path) {
-            throw new PmCliError("--file requires path=<value>", EXIT_CODE.USAGE);
+            throw new PmCliError("--file requires path=<value> or a bare file path", EXIT_CODE.USAGE);
         }
         return {
             path: kv.path,
@@ -559,11 +597,32 @@ export function parseTests(raw) {
         return { values: undefined, explicitEmpty: false };
     assertNoLegacyNoneTokens(raw, "--test", "Use --clear-tests to clear linked tests.");
     const values = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--test");
+        const trimmedEntry = entry.trim();
+        const kv = looksLikeStructuredEntry(trimmedEntry, [
+            "command",
+            "path",
+            "scope",
+            "timeout",
+            "timeout_seconds",
+            "pm_context_mode",
+            "env_set",
+            "env_clear",
+            "shared_host_safe",
+            "assert_stdout_contains",
+            "assert_stdout_regex",
+            "assert_stderr_contains",
+            "assert_stderr_regex",
+            "assert_stdout_min_lines",
+            "assert_json_field_equals",
+            "assert_json_field_gte",
+            "note",
+        ])
+            ? parseCsvKv(entry, "--test")
+            : { command: trimmedEntry };
         const command = parseOptionalString(kv.command);
         const filePath = parseOptionalString(kv.path);
         if (!command) {
-            throw new PmCliError("--test requires command=<value> (path=<value> is optional metadata)", EXIT_CODE.USAGE);
+            throw new PmCliError("--test requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
         }
         const timeoutSecondsRaw = parseOptionalString(kv.timeout_seconds);
         const timeoutAliasRaw = parseOptionalString(kv.timeout);
@@ -597,9 +656,12 @@ export function parseDocs(raw) {
         return { values: undefined, explicitEmpty: false };
     assertNoLegacyNoneTokens(raw, "--doc", "Use --clear-docs to clear linked docs.");
     const values = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--doc");
+        const trimmedEntry = entry.trim();
+        const kv = looksLikeStructuredEntry(trimmedEntry, ["path", "scope", "note"])
+            ? parseCsvKv(entry, "--doc")
+            : { path: trimmedEntry };
         if (!kv.path) {
-            throw new PmCliError("--doc requires path=<value>", EXIT_CODE.USAGE);
+            throw new PmCliError("--doc requires path=<value> or a bare doc path", EXIT_CODE.USAGE);
         }
         return {
             path: kv.path,
@@ -705,9 +767,9 @@ function parseEvents(raw, nowValue) {
     const referenceDate = new Date(nowValue);
     const values = raw.map((entry) => {
         const kv = parseCsvKv(entry, "--event");
-        const startRaw = parseOptionalString(kv.start)?.trim();
+        const startRaw = parseOptionalString(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, referenceDate, "event.start");
         const endRaw = parseOptionalString(kv.end)?.trim();
@@ -1087,21 +1149,20 @@ function ensureInitHasRun(pmRoot) {
     });
 }
 export async function runCreate(options, global) {
-    let resolvedOptions = await resolveCreateStdinInputs(options);
+    let resolvedOptions = normalizeLegacyNoneCreateOptions(await resolveCreateStdinInputs(options));
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
     await ensureInitHasRun(pmRoot);
     const settings = await readSettings(pmRoot);
     const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
     const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
     const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-    assertNoLegacyNoneToken(resolvedOptions.template, "--template", "Omit --template to skip template usage.");
     if (resolvedOptions.template !== undefined) {
         const templateName = resolvedOptions.template.trim();
         if (templateName.length === 0) {
             throw new PmCliError("--template must not be empty. Omit --template to disable template usage.", EXIT_CODE.USAGE);
         }
         const templateOptions = await loadCreateTemplateOptions(pmRoot, templateName);
-        resolvedOptions = mergeCreateOptionsWithTemplate(templateOptions, resolvedOptions);
+        resolvedOptions = normalizeLegacyNoneCreateOptions(mergeCreateOptionsWithTemplate(templateOptions, resolvedOptions));
     }
     if (resolvedOptions.type === undefined) {
         throw new PmCliError("Missing required option --type <value>", EXIT_CODE.USAGE);