@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli/commands/config.d.ts

@@ -1,8 +1,9 @@
 import { type NestedSettingDescriptor } from "../../core/config/nested-settings.js";
 import type { GlobalOptions } from "../../core/shared/command-types.js";
-import type { GovernanceCloseValidationDefault, GovernanceCreateModeDefault, GovernanceOwnershipEnforcement, GovernancePreset, GovernanceWorkflowEnforcement, ItemFormat, ParentReferencePolicy, SprintReleaseFormatPolicy, ValidateMetadataProfile } from "../../types/index.js";
+import type { GovernanceCloseValidationDefault, GovernanceCreateModeDefault, GovernanceOwnershipEnforcement, GovernancePreset, GovernanceWorkflowEnforcement, ItemFormat, ParentReferencePolicy, SprintReleaseFormatPolicy, ValidateMetadataProfile, ValidateMetadataRequiredField } from "../../types/index.js";
 declare const CONFIG_SCOPE_VALUES: readonly ["project", "global"];
 type ConfigScope = (typeof CONFIG_SCOPE_VALUES)[number];
+type ConfigAction = "get" | "set" | "list" | "export";
 type ConfigKey = "definition_of_done" | "item_format" | "history_missing_stream_policy" | "sprint_release_format_policy" | "parent_reference_policy" | "metadata_validation_profile" | "metadata_required_fields" | "lifecycle_stale_blocker_reason_patterns" | "lifecycle_closure_like_blocked_reason_patterns" | "lifecycle_closure_like_resolution_patterns" | "lifecycle_closure_like_actual_result_patterns" | "governance_preset" | "governance_ownership_enforcement" | "governance_create_mode_default" | "governance_close_validation_default" | "governance_require_close_reason" | "governance_create_default_type" | "governance_workflow_enforcement" | "governance_parent_reference_policy" | "governance_metadata_validation_profile" | "governance_force_required_for_stale_lock" | "test_result_tracking" | "telemetry_tracking" | "context";
 type HistoryMissingStreamPolicy = "auto_create" | "strict_error";
 type TestResultTrackingPolicy = "enabled" | "disabled";
@@ -72,5 +73,54 @@ export interface ConfigResult {
     changed: boolean;
     warnings?: string[];
 }
+declare function normalizeScope(value: string): ConfigScope;
+declare function normalizeAction(value: string): ConfigAction;
+declare function normalizeKey(value: string): ConfigKey;
+declare function normalizeCriteria(values: string[] | undefined, clearCriteria: boolean | undefined): string[];
+declare function normalizeItemFormat(value: string | undefined): ItemFormat;
+declare function normalizeHistoryMissingStreamPolicy(value: string | undefined): HistoryMissingStreamPolicy;
+declare function normalizeTestResultTrackingPolicy(value: string | undefined): TestResultTrackingPolicy;
+declare function normalizeTelemetryTrackingPolicy(value: string | undefined): TelemetryTrackingPolicy;
+declare function normalizeValidateMetadataProfile(value: string | undefined): ValidateMetadataProfile;
+declare function normalizeGovernancePreset(value: string | undefined): GovernancePreset;
+declare function normalizeGovernanceOwnershipEnforcement(value: string | undefined): GovernanceOwnershipEnforcement;
+declare function normalizeGovernanceCreateModeDefault(value: string | undefined): GovernanceCreateModeDefault;
+declare function normalizeGovernanceCloseValidationDefault(value: string | undefined): GovernanceCloseValidationDefault;
+declare function normalizeGovernanceWorkflowEnforcement(value: unknown): GovernanceWorkflowEnforcement;
+declare function normalizeGovernanceForceRequiredForStaleLockPolicy(value: string | undefined): GovernanceForceRequiredForStaleLockPolicy;
+declare function normalizeGovernanceRequireCloseReasonPolicy(value: string | undefined): GovernanceRequireCloseReasonPolicy;
+declare function normalizePolicyForConflict(key: ConfigKey | undefined, value: string): string;
+declare function normalizeMetadataRequiredFields(values: string[] | undefined, clearCriteria: boolean | undefined): ValidateMetadataRequiredField[];
+declare function normalizeWarnings(values: string[]): string[];
+/**
+ * Route an intuitive `pm config set <key> <value>` positional value onto the typed
+ * flag it belongs to (--format/--policy/--criterion), applying enabled/disabled
+ * synonyms. Returns the (possibly augmented) options. The typed-flag forms keep
+ * working exactly as before: a positional value is only injected when its flag was
+ * not already supplied, and a conflicting explicit flag is a clear error.
+ */
+declare function applyPositionalValue(action: ConfigAction, keyValue: string | undefined, normalizedKey: ConfigKey | undefined, nestedSetting: NestedSettingDescriptor | undefined, valueValue: string | undefined, options: ConfigCommandOptions): ConfigCommandOptions;
 export declare function runConfig(scopeValue: string, actionValue: string, keyValue: string | undefined, options: ConfigCommandOptions, global: GlobalOptions, valueValue?: string): Promise<ConfigResult>;
+export declare const _testOnlyConfigCommand: {
+    applyPositionalValue: typeof applyPositionalValue;
+    normalizeAction: typeof normalizeAction;
+    normalizeCriteria: typeof normalizeCriteria;
+    normalizeGovernanceCloseValidationDefault: typeof normalizeGovernanceCloseValidationDefault;
+    normalizeGovernanceCreateModeDefault: typeof normalizeGovernanceCreateModeDefault;
+    normalizeGovernanceForceRequiredForStaleLockPolicy: typeof normalizeGovernanceForceRequiredForStaleLockPolicy;
+    normalizeGovernanceOwnershipEnforcement: typeof normalizeGovernanceOwnershipEnforcement;
+    normalizeGovernancePreset: typeof normalizeGovernancePreset;
+    normalizeGovernanceRequireCloseReasonPolicy: typeof normalizeGovernanceRequireCloseReasonPolicy;
+    normalizeGovernanceWorkflowEnforcement: typeof normalizeGovernanceWorkflowEnforcement;
+    normalizeHistoryMissingStreamPolicy: typeof normalizeHistoryMissingStreamPolicy;
+    normalizeItemFormat: typeof normalizeItemFormat;
+    normalizeKey: typeof normalizeKey;
+    normalizeMetadataRequiredFields: typeof normalizeMetadataRequiredFields;
+    normalizePolicyForConflict: typeof normalizePolicyForConflict;
+    normalizeScope: typeof normalizeScope;
+    normalizeTelemetryTrackingPolicy: typeof normalizeTelemetryTrackingPolicy;
+    normalizeTestResultTrackingPolicy: typeof normalizeTestResultTrackingPolicy;
+    normalizeValidateMetadataProfile: typeof normalizeValidateMetadataProfile;
+    normalizeWarnings: typeof normalizeWarnings;
+};
 export {};

package/dist/cli/commands/config.js

@@ -1,5 +1,5 @@
 
-!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]="0a6df339-140f-5018-96e1-782e613aae14")}catch(e){}}();
+!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]="3992ce3b-2841-5df7-ad9c-e799433e9c48")}catch(e){}}();
 import { pathExists } from "../../core/fs/fs-utils.js";
 import { resolveConfigPositionalValue } from "../../core/config/positional-value.js";
 import { NESTED_SETTING_DESCRIPTORS, parseNestedSettingValue, readNestedSettingValue, resolveNestedSettingDescriptor, writeNestedSettingValue, } from "../../core/config/nested-settings.js";
@@ -8,6 +8,7 @@ import { normalizeParentReferencePolicy } from "../../core/item/parent-reference
 import { normalizeSprintReleaseFormatPolicy } from "../../core/item/sprint-release-format.js";
 import { resolveItemTypeRegistry, resolveTypeName } from "../../core/item/type-registry.js";
 import { buildInvalidTypeError } from "../../core/schema/item-types-file.js";
+import { resolveItemTypesFilePath } from "../../core/schema/runtime-schema.js";
 import { EXIT_CODE } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
 import { migrateItemFilesToFormat } from "../../core/store/item-format-migration.js";
@@ -460,6 +461,19 @@ function normalizeKeyForAction(action, value) {
     }
     return normalizeKey(value);
 }
+/**
+ * Narrows the `ConfigKey | undefined` carried into the get/set branches back to
+ * a concrete `ConfigKey`. By the time those branches run, `normalizeKeyForAction`
+ * has already thrown on a missing key and nested settings have returned earlier,
+ * so the `undefined` case is unreachable at runtime — the throw is a defensive
+ * type-narrowing guard only.
+ */
+function assertConfigKeyDefined(key) {
+    /* c8 ignore next 3 -- defensive: get/set always carry a key (see normalizeKeyForAction). */
+    if (!key) {
+        throw new PmCliError("Config action requires <key>", EXIT_CODE.USAGE);
+    }
+}
 function readConfigValue(settings, key) {
     if (key === "item_format") {
         return settings.item_format;
@@ -655,10 +669,12 @@ function applyPositionalValue(action, keyValue, normalizedKey, nestedSetting, va
         if (options.value !== undefined && valueValue !== undefined && options.value !== valueValue) {
             throw new PmCliError(`Config set ${keyValue} received both positional value "${valueValue}" and --value "${options.value}". Pass only one.`, EXIT_CODE.USAGE);
         }
-        // Pick whichever was supplied; do not overwrite a present --value with undefined.
-        return { ...options, value: valueValue ?? options.value };
+        // valueValue is guaranteed defined here (the valueValue === undefined early return
+        // above preserves a pre-existing --value), so this never overwrites --value.
+        return { ...options, value: valueValue };
     }
-    const routed = resolveConfigPositionalValue(normalizedKey ?? keyValue, valueValue);
+    assertConfigKeyDefined(normalizedKey);
+    const routed = resolveConfigPositionalValue(normalizedKey, valueValue);
     if (!routed.routable) {
         throw new PmCliError(routed.reason, EXIT_CODE.USAGE);
     }
@@ -669,10 +685,12 @@ function applyPositionalValue(action, keyValue, normalizedKey, nestedSetting, va
         return { ...options, criterion: routed.values };
     }
     if (routed.flag === "format") {
+        /* c8 ignore start -- only `toon` is valid, so normalized explicit/positional formats cannot conflict. */
         if (options.format !== undefined &&
             normalizeItemFormat(options.format) !== normalizeItemFormat(routed.value)) {
             throw new PmCliError(`Config set ${keyValue} received both positional value "${valueValue}" and --format "${options.format}". Pass only one.`, EXIT_CODE.USAGE);
         }
+        /* c8 ignore stop */
         return { ...options, format: routed.value };
     }
     // policy flag (--policy)
@@ -799,10 +817,10 @@ export async function runConfig(scopeValue, actionValue, keyValue, options, glob
             changed: false,
         }, warnings);
     }
+    // For get/set (non-nested) `normalizeKeyForAction` already guaranteed a key above,
+    // so `key` is defined here. list/export return before reaching these branches.
     if (action === "get") {
-        if (!key) {
-            throw new PmCliError('Config action "get" requires <key>', EXIT_CODE.USAGE);
-        }
+        assertConfigKeyDefined(key);
         if (key === "item_format") {
             return withWarnings({
                 scope,
@@ -1024,9 +1042,7 @@ export async function runConfig(scopeValue, actionValue, keyValue, options, glob
             changed: false,
         }, warnings);
     }
-    if (!key) {
-        throw new PmCliError('Config action "set" requires <key>', EXIT_CODE.USAGE);
-    }
+    assertConfigKeyDefined(key);
     if (options.clearCriteria === true && !isCriteriaConfigKey(key)) {
         throw new PmCliError("--clear-criteria is only supported with config set criteria-list keys", EXIT_CODE.USAGE);
     }
@@ -1312,7 +1328,7 @@ export async function runConfig(scopeValue, actionValue, keyValue, options, glob
         const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
         const resolvedType = resolveTypeName(rawType, typeRegistry);
         if (!resolvedType) {
-            throw new PmCliError(buildInvalidTypeError(rawType, typeRegistry.types), EXIT_CODE.USAGE);
+            throw new PmCliError(buildInvalidTypeError(rawType, typeRegistry.types, resolveItemTypesFilePath(target.pmRoot, settings.schema)), EXIT_CODE.USAGE);
         }
         const changed = settings.governance.create_default_type !== resolvedType;
         settings.governance.create_default_type = resolvedType;
@@ -1445,5 +1461,27 @@ export async function runConfig(scopeValue, actionValue, keyValue, options, glob
         changed,
     }, warnings);
 }
+export const _testOnlyConfigCommand = {
+    applyPositionalValue,
+    normalizeAction,
+    normalizeCriteria,
+    normalizeGovernanceCloseValidationDefault,
+    normalizeGovernanceCreateModeDefault,
+    normalizeGovernanceForceRequiredForStaleLockPolicy,
+    normalizeGovernanceOwnershipEnforcement,
+    normalizeGovernancePreset,
+    normalizeGovernanceRequireCloseReasonPolicy,
+    normalizeGovernanceWorkflowEnforcement,
+    normalizeHistoryMissingStreamPolicy,
+    normalizeItemFormat,
+    normalizeKey,
+    normalizeMetadataRequiredFields,
+    normalizePolicyForConflict,
+    normalizeScope,
+    normalizeTelemetryTrackingPolicy,
+    normalizeTestResultTrackingPolicy,
+    normalizeValidateMetadataProfile,
+    normalizeWarnings,
+};
 //# sourceMappingURL=config.js.map
-//# debugId=0a6df339-140f-5018-96e1-782e613aae14
+//# debugId=3992ce3b-2841-5df7-ad9c-e799433e9c48