@unbrained/pm-cli 2026.6.16 → 2026.6.17

package/dist/cli/register-mutation.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]="77fb8735-3d70-59c2-86f3-3e6462688b5d")}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]="e38412ec-cbfb-5416-8790-6ca1958f596b")}catch(e){}}();
 import { Option } from "commander";
 import { resolveBodyFileContent } from "../core/io/body-file.js";
 import { EXIT_CODE } from "../core/shared/constants.js";
@@ -55,6 +55,120 @@ export function parseSchemaOrderOption(raw) {
     }
     throw new PmCliError("--order must be a finite integer.", EXIT_CODE.USAGE);
 }
+/**
+ * Routes a normalized `pm schema` subcommand to its run function. Extracted from
+ * the schema `.action()` body so the per-subcommand dispatch lives in one
+ * single-purpose function and registerMutationCommands stays under the
+ * cyclomatic-complexity gate.
+ */
+async function dispatchSchemaSubcommand(schema, inputs) {
+    const { normalizedSubcommand, typeName, options, globalOptions } = inputs;
+    const { author, force, description } = inputs;
+    switch (normalizedSubcommand) {
+        case "list":
+            return schema.runSchemaList(globalOptions);
+        case "show":
+            return schema.runSchemaShow(typeName, globalOptions);
+        case "show-status":
+            return schema.runSchemaShowStatus(typeName, globalOptions);
+        case "list-fields":
+            return schema.runSchemaListFields(globalOptions);
+        case "show-field":
+            return schema.runSchemaShowField(typeName, globalOptions);
+        case "remove-type":
+            return schema.runSchemaRemoveType(typeName, { author, force }, globalOptions);
+        case "remove-field":
+            return schema.runSchemaRemoveField(typeName, { author, force }, globalOptions);
+        case "apply-preset":
+            return schema.runSchemaApplyPreset(typeName, { author, force }, globalOptions);
+        case "add-field":
+            return schema.runSchemaAddField(typeName, {
+                type: typeof options.type === "string" ? options.type : undefined,
+                commands: inputs.commands,
+                description,
+                cliFlag: typeof options.cliFlag === "string" ? options.cliFlag : undefined,
+                alias: inputs.aliases,
+                required: Boolean(options.required),
+                requiredOnCreate: Boolean(options.requiredOnCreate),
+                // commander stores --no-allow-unset as allowUnset:false; the default
+                // (flag omitted) is true. Forward the tri-state faithfully.
+                allowUnset: options.allowUnset !== false,
+                requiredTypes: inputs.requiredTypes,
+                author,
+                force,
+            }, globalOptions);
+        case "add-status":
+            return schema.runSchemaAddStatus(typeName, { role: inputs.roles, alias: inputs.aliases, description, order: inputs.order, author, force }, globalOptions);
+        case "remove-status":
+            return schema.runSchemaRemoveStatus(typeName, { author, force }, globalOptions);
+        default:
+            // add-type, optionally in --infer mode.
+            if (options.infer === true) {
+                return schema.runSchemaInferTypes({ minCount: inputs.minCount, apply: Boolean(options.apply), author, force }, globalOptions);
+            }
+            return schema.runSchemaAddType(typeName, {
+                description,
+                defaultStatus: inputs.defaultStatus,
+                folder: typeof options.folder === "string" ? options.folder : undefined,
+                alias: inputs.aliases,
+                author,
+                force,
+            }, globalOptions);
+    }
+}
+/**
+ * Renders a schema command result for non-JSON, non-quiet output and surfaces
+ * any on-write hook warnings. Extracted from the schema `.action()` body to keep
+ * registerMutationCommands under the cyclomatic-complexity gate.
+ */
+function renderSchemaResultHuman(schema, result) {
+    switch (result.action) {
+        case "list":
+            writeStdout(`${schema.formatSchemaListHuman(result)}\n`);
+            return;
+        case "show":
+            writeStdout(`${schema.formatSchemaShowHuman(result)}\n`);
+            return;
+        case "show-status":
+            writeStdout(`${schema.formatSchemaShowStatusHuman(result)}\n`);
+            return;
+        case "list-fields":
+            writeStdout(`${schema.formatSchemaListFieldsHuman(result)}\n`);
+            return;
+        case "show-field":
+            writeStdout(`${schema.formatSchemaShowFieldHuman(result)}\n`);
+            return;
+        case "remove-type":
+            writeStdout(`${schema.formatSchemaRemoveTypeHuman(result)}\n`);
+            break;
+        case "remove-field":
+            writeStdout(`${schema.formatSchemaRemoveFieldHuman(result)}\n`);
+            break;
+        case "apply-preset":
+            writeStdout(`${schema.formatSchemaApplyPresetHuman(result)}\n`);
+            break;
+        case "infer-types":
+            writeStdout(`${schema.formatSchemaInferTypesHuman(result)}\n`);
+            break;
+        case "add-field":
+            writeStdout(`${schema.formatSchemaAddFieldHuman(result)}\n`);
+            break;
+        case "add-status":
+            writeStdout(`${schema.formatSchemaAddStatusHuman(result)}\n`);
+            break;
+        case "remove-status":
+            writeStdout(`${schema.formatSchemaRemoveStatusHuman(result)}\n`);
+            break;
+        default:
+            writeStdout(`${schema.formatSchemaAddTypeHuman(result)}\n`);
+            break;
+    }
+    // Surface extension on-write hook diagnostics (mutation subcommands only;
+    // inspection results carry no warnings array).
+    if (result.warnings.length > 0) {
+        printError(`schema ${result.action} warnings: ${formatHookWarnings(result.warnings)}`);
+    }
+}
 /**
  * Build a commander argParser that coerces a flag value into a positive
  * (1-based) integer, throwing a usage error when the supplied value is not a
@@ -1066,22 +1180,33 @@ export function registerMutationCommands(program) {
         .command("schema")
         .argument("[subcommand]", "Schema subcommand: list, show, show-status, add-type, remove-type, add-status, remove-status, or a custom item type name shorthand")
         .argument("[name]", "Item type name (add-type/remove-type/show) or status id (show-status/add-status/remove-status)")
-        .option("--description <text>", "Human description for the custom item type or status")
+        .option("--description <text>", "Human description for the custom item type, status, or field")
         .option("--default-status <status>", "Default status hint recorded for the custom item type")
         .option("--folder <dir>", "Storage folder for items of this custom type")
-        .option("--alias <name>", "Alias for the custom type or status (repeatable, csv-friendly)", collect)
+        .option("--alias <name>", "Alias for the custom type, status, or field flag (repeatable, csv-friendly)", collect)
         .option("--role <value>", "Lifecycle role for a custom status (repeatable): draft, active, blocked, terminal, terminal_done, terminal_canceled, default_open, default_close, default_cancel", collect)
         .option("--order <n>", "Display/sort order for a custom status")
+        .option("--type <type>", "Value type for a custom field (add-field): string, number, boolean, string_array")
+        .option("--commands <list>", "Commands a custom field is wired onto (add-field; repeatable, comma-friendly): create, update, update_many, list, search, calendar, context", collect)
+        .option("--cli-flag <flag>", "Override the auto-derived CLI flag for a custom field (add-field)")
+        .option("--required", "Mark a custom field as always required (add-field)")
+        .option("--required-on-create", "Mark a custom field as required at create time (add-field)")
+        .option("--no-allow-unset", "Disallow clearing a custom field via --unset (add-field)")
+        .option("--required-types <list>", "Restrict a custom field's requirement to specific item types (add-field; repeatable, comma-friendly)", collect)
+        .option("--infer", "Infer custom item types from title-prefix conventions (add-type; preview unless --apply)")
+        .option("--min-count <n>", "Minimum items sharing a prefix for add-type --infer (default 10)")
+        .option("--apply", "Register inferred types (add-type --infer); without it the command previews only")
         .option("--author <value>", "Mutation author")
         .option("--force", "Force ownership/lock override")
-        .description("Inspect and manage config-driven runtime schema.");
+        .description("Inspect and manage config-driven runtime schema (types, statuses, fields, presets).");
     // Hidden pure snake_case underscore-duplicate alias.
     addHiddenOption(schemaCommand, "--default_status <status>", "Alias for --default-status", false);
     schemaCommand
         .action(async (subcommand, name, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runSchemaAddType, runSchemaRemoveType, runSchemaAddStatus, runSchemaRemoveStatus, runSchemaList, runSchemaShow, runSchemaShowStatus, formatSchemaAddTypeHuman, formatSchemaRemoveTypeHuman, formatSchemaAddStatusHuman, formatSchemaRemoveStatusHuman, formatSchemaListHuman, formatSchemaShowHuman, formatSchemaShowStatusHuman, SCHEMA_SUBCOMMANDS, } = await import("./commands/schema.js");
+        const schemaModule = await import("./commands/schema.js");
+        const { SCHEMA_SUBCOMMANDS } = schemaModule;
         let normalizedSubcommand = (subcommand ?? "").trim().toLowerCase();
         let typeName = name;
         if (!normalizedSubcommand) {
@@ -1095,6 +1220,10 @@ export function registerMutationCommands(program) {
                     "pm schema remove-type Spike",
                     "pm schema add-status review --role active --alias in_review",
                     "pm schema remove-status review",
+                    "pm schema add-field severity_level --type string --commands create,update",
+                    "pm schema list-fields",
+                    "pm schema apply-preset agile",
+                    "pm schema add-type --infer --min-count 10",
                 ],
             });
         }
@@ -1118,6 +1247,21 @@ export function registerMutationCommands(program) {
                 ? options.default_status
                 : undefined;
         const order = parseSchemaOrderOption(options.order);
+        // --commands/--required-types are repeatable Commander `collect` flags, so
+        // their value is always a string[] (or undefined when omitted); each entry
+        // may itself be a comma-list, which we split and flatten here.
+        const splitCommaList = (raw) => {
+            if (!Array.isArray(raw)) {
+                return undefined;
+            }
+            return raw
+                .flatMap((value) => value.split(","))
+                .map((value) => value.trim())
+                .filter((value) => value.length > 0);
+        };
+        const commands = splitCommaList(options.commands);
+        const requiredTypes = splitCommaList(options.requiredTypes);
+        const minCount = parseSchemaOrderOption(options.minCount);
         if (!SCHEMA_SUBCOMMANDS.includes(normalizedSubcommand) && typeName === undefined) {
             typeName = subcommand;
             normalizedSubcommand = "add-type";
@@ -1127,67 +1271,29 @@ export function registerMutationCommands(program) {
         }
         const author = typeof options.author === "string" ? options.author : undefined;
         const force = Boolean(options.force);
-        const result = normalizedSubcommand === "list"
-            ? await runSchemaList(globalOptions)
-            : normalizedSubcommand === "show"
-                ? await runSchemaShow(typeName, globalOptions)
-                : normalizedSubcommand === "show-status"
-                    ? await runSchemaShowStatus(typeName, globalOptions)
-                    : normalizedSubcommand === "remove-type"
-                        ? await runSchemaRemoveType(typeName, { author, force }, globalOptions)
-                        : normalizedSubcommand === "add-status"
-                            ? await runSchemaAddStatus(typeName, {
-                                role: roles,
-                                alias: aliases,
-                                description: typeof options.description === "string" ? options.description : undefined,
-                                order,
-                                author,
-                                force,
-                            }, globalOptions)
-                            : normalizedSubcommand === "remove-status"
-                                ? await runSchemaRemoveStatus(typeName, { author, force }, globalOptions)
-                                : await runSchemaAddType(typeName, {
-                                    description: typeof options.description === "string" ? options.description : undefined,
-                                    defaultStatus,
-                                    folder: typeof options.folder === "string" ? options.folder : undefined,
-                                    alias: aliases,
-                                    author,
-                                    force,
-                                }, globalOptions);
+        const description = typeof options.description === "string" ? options.description : undefined;
+        const result = await dispatchSchemaSubcommand(schemaModule, {
+            normalizedSubcommand,
+            typeName,
+            options,
+            aliases,
+            roles,
+            commands,
+            requiredTypes,
+            defaultStatus,
+            order,
+            minCount,
+            author,
+            force,
+            description,
+            globalOptions,
+        });
         // Schema inspection and type registration do not touch item content, so search caches stay valid.
         if (globalOptions.json === true || globalOptions.defaultOutputFormat === "json") {
             printResult(result, globalOptions);
         }
         else if (!globalOptions.quiet) {
-            if (result.action === "list") {
-                writeStdout(`${formatSchemaListHuman(result)}\n`);
-            }
-            else if (result.action === "show") {
-                writeStdout(`${formatSchemaShowHuman(result)}\n`);
-            }
-            else if (result.action === "show-status") {
-                writeStdout(`${formatSchemaShowStatusHuman(result)}\n`);
-            }
-            else if (result.action === "remove-type") {
-                writeStdout(`${formatSchemaRemoveTypeHuman(result)}\n`);
-            }
-            else if (result.action === "add-status") {
-                writeStdout(`${formatSchemaAddStatusHuman(result)}\n`);
-            }
-            else if (result.action === "remove-status") {
-                writeStdout(`${formatSchemaRemoveStatusHuman(result)}\n`);
-            }
-            else {
-                writeStdout(`${formatSchemaAddTypeHuman(result)}\n`);
-            }
-            // Surface extension on-write hook diagnostics so policy/enforcement
-            // warnings are visible without forcing --json.
-            if (result.action !== "list" &&
-                result.action !== "show" &&
-                result.action !== "show-status" &&
-                result.warnings.length > 0) {
-                printError(`schema ${result.action} warnings: ${formatHookWarnings(result.warnings)}`);
-            }
+            renderSchemaResultHuman(schemaModule, result);
         }
         if (globalOptions.profile) {
             printError(`profile:command=schema took_ms=${Date.now() - startedAt}`);
@@ -1480,4 +1586,4 @@ export function registerMutationCommands(program) {
     });
 }
 //# sourceMappingURL=register-mutation.js.map
-//# debugId=77fb8735-3d70-59c2-86f3-3e6462688b5d
+//# debugId=e38412ec-cbfb-5416-8790-6ca1958f596b