@unbrained/pm-cli 2026.5.1 → 2026.5.3-5

package/dist/cli/registration-helpers.js

@@ -0,0 +1,669 @@
+import { pathExists } from "../core/fs/fs-utils.js";
+import { refreshSearchArtifactsForMutation } from "../core/search/cache.js";
+import { EXIT_CODE } from "../core/shared/constants.js";
+import { PmCliError } from "../core/shared/errors.js";
+import { printError, printResult, writeStdout } from "../core/output/output.js";
+import { getSettingsPath, resolvePmRoot } from "../core/store/paths.js";
+import { readSettings } from "../core/store/settings.js";
+import { setActiveCommandResult, } from "../core/extensions/index.js";
+import { ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS, CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS, CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS, CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, CREATE_COMMANDER_STRING_OPTION_CONTRACTS, LIST_COMMANDER_STRING_OPTION_CONTRACTS, SEARCH_COMMANDER_STRING_OPTION_CONTRACTS, UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, UPDATE_COMMANDER_STRING_OPTION_CONTRACTS, readFirstStringFromCommanderOptions, readStringArrayFromCommanderOptions, } from "../sdk/cli-contracts.js";
+export { printError, printResult, writeStdout, };
+const RESOLVED_GLOBAL_OPTIONS = Symbol("pm.resolvedGlobalOptions");
+export function setResolvedGlobalOptions(command, globalOptions) {
+    command[RESOLVED_GLOBAL_OPTIONS] = { ...globalOptions };
+}
+export function clearResolvedGlobalOptions(command) {
+    delete command[RESOLVED_GLOBAL_OPTIONS];
+}
+export function getGlobalOptions(command) {
+    const resolved = command[RESOLVED_GLOBAL_OPTIONS];
+    if (resolved) {
+        return { ...resolved };
+    }
+    const opts = command.optsWithGlobals();
+    return {
+        json: opts.json === true ? true : undefined,
+        quiet: Boolean(opts.quiet),
+        path: typeof opts.path === "string" ? opts.path : undefined,
+        noExtensions: opts.extensions === false,
+        noPager: Boolean(opts.noPager),
+        profile: Boolean(opts.profile),
+    };
+}
+export function getCommandPath(command) {
+    const parts = [];
+    let current = command;
+    while (current?.parent) {
+        parts.unshift(current.name());
+        current = current.parent;
+    }
+    return parts.join(" ");
+}
+export async function applyDefaultOutputFormat(globalOptions) {
+    if (globalOptions.json === true) {
+        return globalOptions;
+    }
+    const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+    if (!(await pathExists(getSettingsPath(pmRoot)))) {
+        return globalOptions;
+    }
+    const settings = await readSettings(pmRoot);
+    return {
+        ...globalOptions,
+        defaultOutputFormat: settings.output.default_format,
+    };
+}
+export function collect(value, previous) {
+    const next = previous ?? [];
+    next.push(value);
+    return next;
+}
+export function pushOptionalValueFlag(args, flag, value) {
+    if (typeof value !== "string") {
+        return;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return;
+    }
+    args.push(flag, trimmed);
+}
+export function pushOptionalBooleanFlag(args, flag, value) {
+    if (value === true) {
+        args.push(flag);
+    }
+}
+export function pushRepeatableValueFlag(args, flag, values) {
+    if (!Array.isArray(values)) {
+        return;
+    }
+    for (const value of values) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        args.push(flag, trimmed);
+    }
+}
+export function buildBackgroundTestCommandArgs(id, options) {
+    const args = ["test", id, "--run", "--json", "--progress"];
+    pushRepeatableValueFlag(args, "--add", options.add);
+    pushRepeatableValueFlag(args, "--remove", options.remove);
+    pushOptionalValueFlag(args, "--timeout", options.timeout);
+    pushRepeatableValueFlag(args, "--env-set", options.envSet);
+    pushRepeatableValueFlag(args, "--env-clear", options.envClear);
+    pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
+    pushOptionalValueFlag(args, "--pm-context", options.pmContext);
+    pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+    pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
+    pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
+    pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
+    pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
+    pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
+    pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
+    pushOptionalValueFlag(args, "--author", options.author);
+    pushOptionalValueFlag(args, "--message", options.message);
+    pushOptionalBooleanFlag(args, "--force", options.force);
+    return args;
+}
+export function buildBackgroundTestAllCommandArgs(options) {
+    const args = ["test-all", "--json", "--progress"];
+    pushOptionalValueFlag(args, "--status", options.status);
+    pushOptionalValueFlag(args, "--limit", options.limit);
+    pushOptionalValueFlag(args, "--offset", options.offset);
+    pushOptionalValueFlag(args, "--timeout", options.timeout);
+    pushRepeatableValueFlag(args, "--env-set", options.envSet);
+    pushRepeatableValueFlag(args, "--env-clear", options.envClear);
+    pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
+    pushOptionalValueFlag(args, "--pm-context", options.pmContext);
+    pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
+    pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
+    pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
+    pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
+    pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
+    pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
+    pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
+    return args;
+}
+export function formatHookWarnings(warnings) {
+    return warnings.join(",");
+}
+export function normalizeCreateOptions(commandOptions, options = {}) {
+    const readCreateString = (target) => readFirstStringFromCommanderOptions(commandOptions, CREATE_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const readCreateList = (target) => readStringArrayFromCommanderOptions(commandOptions, CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const type = readCreateString("type");
+    if (options.requireType !== false && type === undefined) {
+        throw new PmCliError("Missing required option --type <value>", EXIT_CODE.USAGE);
+    }
+    const normalized = {
+        title: readCreateString("title"),
+        description: readCreateString("description"),
+        type,
+        template: readCreateString("template"),
+        createMode: readCreateString("createMode"),
+        schedulePreset: readCreateString("schedulePreset"),
+        status: readCreateString("status"),
+        priority: readCreateString("priority"),
+        tags: readCreateString("tags"),
+        body: readCreateString("body"),
+        deadline: readCreateString("deadline"),
+        estimatedMinutes: readCreateString("estimatedMinutes"),
+        acceptanceCriteria: readCreateString("acceptanceCriteria"),
+        definitionOfReady: readCreateString("definitionOfReady"),
+        order: readCreateString("order"),
+        rank: readCreateString("rank"),
+        goal: readCreateString("goal"),
+        objective: readCreateString("objective"),
+        value: readCreateString("value"),
+        impact: readCreateString("impact"),
+        outcome: readCreateString("outcome"),
+        whyNow: readCreateString("whyNow"),
+        author: readCreateString("author"),
+        message: readCreateString("message"),
+        assignee: readCreateString("assignee"),
+        parent: readCreateString("parent"),
+        reviewer: readCreateString("reviewer"),
+        risk: readCreateString("risk"),
+        confidence: readCreateString("confidence"),
+        sprint: readCreateString("sprint"),
+        release: readCreateString("release"),
+        blockedBy: readCreateString("blockedBy"),
+        blockedReason: readCreateString("blockedReason"),
+        unblockNote: readCreateString("unblockNote"),
+        reporter: readCreateString("reporter"),
+        severity: readCreateString("severity"),
+        environment: readCreateString("environment"),
+        reproSteps: readCreateString("reproSteps"),
+        resolution: readCreateString("resolution"),
+        expectedResult: readCreateString("expectedResult"),
+        actualResult: readCreateString("actualResult"),
+        affectedVersion: readCreateString("affectedVersion"),
+        fixedVersion: readCreateString("fixedVersion"),
+        component: readCreateString("component"),
+        regression: readCreateString("regression"),
+        customerImpact: readCreateString("customerImpact"),
+        dep: readCreateList("dep"),
+        comment: readCreateList("comment"),
+        note: readCreateList("note"),
+        learning: readCreateList("learning"),
+        file: readCreateList("file"),
+        test: readCreateList("test"),
+        doc: readCreateList("doc"),
+        reminder: readCreateList("reminder"),
+        event: readCreateList("event"),
+        typeOption: readCreateList("typeOption"),
+        unset: readCreateList("unset"),
+        clearDeps: commandOptions.clearDeps === true ? true : undefined,
+        clearComments: commandOptions.clearComments === true ? true : undefined,
+        clearNotes: commandOptions.clearNotes === true ? true : undefined,
+        clearLearnings: commandOptions.clearLearnings === true ? true : undefined,
+        clearFiles: commandOptions.clearFiles === true ? true : undefined,
+        clearTests: commandOptions.clearTests === true ? true : undefined,
+        clearDocs: commandOptions.clearDocs === true ? true : undefined,
+        clearReminders: commandOptions.clearReminders === true ? true : undefined,
+        clearEvents: commandOptions.clearEvents === true ? true : undefined,
+        clearTypeOptions: commandOptions.clearTypeOptions === true ? true : undefined,
+    };
+    for (const [key, value] of Object.entries(commandOptions)) {
+        if (Object.hasOwn(normalized, key)) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+export function normalizeUpdateOptions(commandOptions) {
+    const readUpdateString = (target) => readFirstStringFromCommanderOptions(commandOptions, UPDATE_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const readUpdateList = (target) => readStringArrayFromCommanderOptions(commandOptions, UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const normalized = {
+        title: readUpdateString("title"),
+        description: readUpdateString("description"),
+        body: readUpdateString("body"),
+        status: readUpdateString("status"),
+        closeReason: readUpdateString("closeReason"),
+        priority: readUpdateString("priority"),
+        type: readUpdateString("type"),
+        tags: readUpdateString("tags"),
+        deadline: readUpdateString("deadline"),
+        estimatedMinutes: readUpdateString("estimatedMinutes"),
+        acceptanceCriteria: readUpdateString("acceptanceCriteria"),
+        definitionOfReady: readUpdateString("definitionOfReady"),
+        order: readUpdateString("order"),
+        rank: readUpdateString("rank"),
+        goal: readUpdateString("goal"),
+        objective: readUpdateString("objective"),
+        value: readUpdateString("value"),
+        impact: readUpdateString("impact"),
+        outcome: readUpdateString("outcome"),
+        whyNow: readUpdateString("whyNow"),
+        author: readUpdateString("author"),
+        message: readUpdateString("message"),
+        force: Boolean(commandOptions.force),
+        allowAuditUpdate: commandOptions.allowAuditUpdate === true || commandOptions.allow_audit_update === true ? true : undefined,
+        allowAuditDepUpdate: commandOptions.allowAuditDepUpdate === true || commandOptions.allow_audit_dep_update === true ? true : undefined,
+        assignee: readUpdateString("assignee"),
+        parent: readUpdateString("parent"),
+        reviewer: readUpdateString("reviewer"),
+        risk: readUpdateString("risk"),
+        confidence: readUpdateString("confidence"),
+        sprint: readUpdateString("sprint"),
+        release: readUpdateString("release"),
+        blockedBy: readUpdateString("blockedBy"),
+        blockedReason: readUpdateString("blockedReason"),
+        unblockNote: readUpdateString("unblockNote"),
+        reporter: readUpdateString("reporter"),
+        severity: readUpdateString("severity"),
+        environment: readUpdateString("environment"),
+        reproSteps: readUpdateString("reproSteps"),
+        resolution: readUpdateString("resolution"),
+        expectedResult: readUpdateString("expectedResult"),
+        actualResult: readUpdateString("actualResult"),
+        affectedVersion: readUpdateString("affectedVersion"),
+        fixedVersion: readUpdateString("fixedVersion"),
+        component: readUpdateString("component"),
+        regression: readUpdateString("regression"),
+        customerImpact: readUpdateString("customerImpact"),
+        dep: readUpdateList("dep"),
+        depRemove: readUpdateList("depRemove"),
+        replaceDeps: commandOptions.replaceDeps === true ? true : undefined,
+        replaceTests: commandOptions.replaceTests === true ? true : undefined,
+        comment: readUpdateList("comment"),
+        note: readUpdateList("note"),
+        learning: readUpdateList("learning"),
+        file: readUpdateList("file"),
+        test: readUpdateList("test"),
+        doc: readUpdateList("doc"),
+        reminder: readUpdateList("reminder"),
+        event: readUpdateList("event"),
+        typeOption: readUpdateList("typeOption"),
+        unset: readUpdateList("unset"),
+        clearDeps: commandOptions.clearDeps === true ? true : undefined,
+        clearComments: commandOptions.clearComments === true ? true : undefined,
+        clearNotes: commandOptions.clearNotes === true ? true : undefined,
+        clearLearnings: commandOptions.clearLearnings === true ? true : undefined,
+        clearFiles: commandOptions.clearFiles === true ? true : undefined,
+        clearTests: commandOptions.clearTests === true ? true : undefined,
+        clearDocs: commandOptions.clearDocs === true ? true : undefined,
+        clearReminders: commandOptions.clearReminders === true ? true : undefined,
+        clearEvents: commandOptions.clearEvents === true ? true : undefined,
+        clearTypeOptions: commandOptions.clearTypeOptions === true ? true : undefined,
+    };
+    for (const [key, value] of Object.entries(commandOptions)) {
+        if (Object.hasOwn(normalized, key)) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+export const UPDATE_MANY_CONTROL_OPTION_KEYS = new Set([
+    "filterStatus",
+    "filterType",
+    "filterTag",
+    "filterPriority",
+    "filterDeadlineBefore",
+    "filterDeadlineAfter",
+    "filterAssignee",
+    "filterAssigneeFilter",
+    "filterAssignee_filter",
+    "filterParent",
+    "filterSprint",
+    "filterRelease",
+    "limit",
+    "offset",
+    "dryRun",
+    "rollback",
+    "checkpoint",
+]);
+export function extractUpdateManyMutationOptionSource(commandOptions) {
+    const mutationOptions = {};
+    for (const [key, value] of Object.entries(commandOptions)) {
+        if (UPDATE_MANY_CONTROL_OPTION_KEYS.has(key)) {
+            continue;
+        }
+        mutationOptions[key] = value;
+    }
+    return mutationOptions;
+}
+function readListOptionString(options, target) {
+    return readFirstStringFromCommanderOptions(options, LIST_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+}
+export function normalizeListOptions(options) {
+    const normalized = {
+        status: readListOptionString(options, "status"),
+        type: readListOptionString(options, "type"),
+        tag: readListOptionString(options, "tag"),
+        priority: readListOptionString(options, "priority"),
+        deadlineBefore: readListOptionString(options, "deadlineBefore"),
+        deadlineAfter: readListOptionString(options, "deadlineAfter"),
+        assignee: readListOptionString(options, "assignee"),
+        assigneeFilter: readListOptionString(options, "assigneeFilter"),
+        parent: readListOptionString(options, "parent"),
+        sprint: readListOptionString(options, "sprint"),
+        release: readListOptionString(options, "release"),
+        limit: readListOptionString(options, "limit"),
+        offset: readListOptionString(options, "offset"),
+        includeBody: options.includeBody === true ? true : undefined,
+        compact: options.compact === true ? true : undefined,
+        fields: readListOptionString(options, "fields"),
+        sort: readListOptionString(options, "sort"),
+        order: readListOptionString(options, "order"),
+    };
+    for (const [key, value] of Object.entries(options)) {
+        if (Object.hasOwn(normalized, key)) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+export function normalizeAggregateOptions(options) {
+    return {
+        groupBy: typeof options.groupBy === "string" ? options.groupBy : undefined,
+        count: options.count === true ? true : undefined,
+        includeUnparented: options.includeUnparented === true || options.include_unparented === true,
+        status: typeof options.status === "string" ? options.status : undefined,
+        type: readListOptionString(options, "type"),
+        tag: readListOptionString(options, "tag"),
+        priority: readListOptionString(options, "priority"),
+        deadlineBefore: readListOptionString(options, "deadlineBefore"),
+        deadlineAfter: readListOptionString(options, "deadlineAfter"),
+        assignee: readListOptionString(options, "assignee"),
+        assigneeFilter: readListOptionString(options, "assigneeFilter"),
+        parent: readListOptionString(options, "parent"),
+        sprint: readListOptionString(options, "sprint"),
+        release: readListOptionString(options, "release"),
+    };
+}
+export function normalizeDedupeAuditOptions(options) {
+    return {
+        mode: typeof options.mode === "string" ? options.mode : undefined,
+        status: typeof options.status === "string" ? options.status : undefined,
+        type: readListOptionString(options, "type"),
+        tag: readListOptionString(options, "tag"),
+        priority: readListOptionString(options, "priority"),
+        deadlineBefore: readListOptionString(options, "deadlineBefore"),
+        deadlineAfter: readListOptionString(options, "deadlineAfter"),
+        assignee: readListOptionString(options, "assignee"),
+        assigneeFilter: readListOptionString(options, "assigneeFilter"),
+        parent: readListOptionString(options, "parent"),
+        sprint: readListOptionString(options, "sprint"),
+        release: readListOptionString(options, "release"),
+        limit: readListOptionString(options, "limit"),
+        threshold: typeof options.threshold === "string" ? options.threshold : undefined,
+    };
+}
+export function printListJsonStream(commandName, result, globalOptions) {
+    setActiveCommandResult(result);
+    if (globalOptions.quiet) {
+        return;
+    }
+    const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+    const metaPayload = {
+        type: "meta",
+        command: commandName,
+        count: result.count,
+        now: result.now,
+        filters: result.filters,
+    };
+    if (warnings.length > 0) {
+        metaPayload.warnings = warnings;
+    }
+    if (!writeStdout(`${JSON.stringify(metaPayload)}\n`)) {
+        return;
+    }
+    for (const item of result.items) {
+        if (!writeStdout(`${JSON.stringify({ type: "item", command: commandName, item })}\n`)) {
+            return;
+        }
+    }
+    writeStdout(`${JSON.stringify({ type: "end", command: commandName, count: result.count })}\n`);
+}
+export function printActivityJsonStream(result, options, globalOptions) {
+    setActiveCommandResult(result);
+    if (globalOptions.quiet) {
+        return;
+    }
+    const metaPayload = {
+        type: "meta",
+        command: "activity",
+        count: result.count,
+        filters: {
+            id: options.id ?? null,
+            op: options.op ?? null,
+            author: options.author ?? null,
+            from: options.from ?? null,
+            to: options.to ?? null,
+            limit: options.limit ?? null,
+        },
+    };
+    if (!writeStdout(`${JSON.stringify(metaPayload)}\n`)) {
+        return;
+    }
+    const entries = result.compact && result.compact_activity ? result.compact_activity : result.activity;
+    for (const entry of entries) {
+        if (!writeStdout(`${JSON.stringify({ type: "entry", command: "activity", entry })}\n`)) {
+            return;
+        }
+    }
+    writeStdout(`${JSON.stringify({ type: "end", command: "activity", count: result.count })}\n`);
+}
+export function normalizeSearchOptions(options) {
+    const readSearchString = (target) => readFirstStringFromCommanderOptions(options, SEARCH_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const fields = readSearchString("fields");
+    const compactRequested = options.compact === true;
+    const fullRequested = options.full === true;
+    const defaultCompact = !compactRequested && !fullRequested && fields === undefined;
+    const normalized = {
+        mode: readSearchString("mode"),
+        includeLinked: options.includeLinked === true ? true : undefined,
+        titleExact: options.titleExact === true ? true : undefined,
+        phraseExact: options.phraseExact === true ? true : undefined,
+        type: readSearchString("type"),
+        tag: readSearchString("tag"),
+        priority: readSearchString("priority"),
+        deadlineBefore: readSearchString("deadlineBefore"),
+        deadlineAfter: readSearchString("deadlineAfter"),
+        limit: readSearchString("limit"),
+        fields,
+        compact: compactRequested || defaultCompact ? true : undefined,
+        full: fullRequested ? true : undefined,
+    };
+    for (const [key, value] of Object.entries(options)) {
+        if (Object.hasOwn(normalized, key)) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+export function normalizeSearchKeywordsInput(keywords) {
+    const query = keywords
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .join(" ");
+    if (query.length === 0) {
+        throw new PmCliError("Search query must not be empty", EXIT_CODE.USAGE);
+    }
+    return query;
+}
+export function normalizeCalendarOptions(options) {
+    const readCalendarString = (target) => readFirstStringFromCommanderOptions(options, CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const normalized = {
+        view: readCalendarString("view"),
+        date: readCalendarString("date"),
+        from: readCalendarString("from"),
+        to: readCalendarString("to"),
+        past: options.past === true ? true : undefined,
+        fullPeriod: options.fullPeriod === true || options.full_period === true ? true : undefined,
+        limit: readCalendarString("limit"),
+        type: readCalendarString("type"),
+        tag: readCalendarString("tag"),
+        priority: readCalendarString("priority"),
+        status: readCalendarString("status"),
+        assignee: readCalendarString("assignee"),
+        assigneeFilter: readCalendarString("assigneeFilter"),
+        sprint: readCalendarString("sprint"),
+        release: readCalendarString("release"),
+        include: readCalendarString("include"),
+        recurrenceLookaheadDays: readCalendarString("recurrenceLookaheadDays"),
+        recurrenceLookbackDays: readCalendarString("recurrenceLookbackDays"),
+        occurrenceLimit: readCalendarString("occurrenceLimit"),
+        format: readCalendarString("format"),
+    };
+    for (const [key, value] of Object.entries(options)) {
+        if (Object.hasOwn(normalized, key)) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+export function normalizeActivityOptions(options) {
+    const readActivityString = (target) => readFirstStringFromCommanderOptions(options, ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    return {
+        id: readActivityString("id"),
+        op: readActivityString("op"),
+        author: readActivityString("author"),
+        from: readActivityString("from"),
+        to: readActivityString("to"),
+        limit: readActivityString("limit"),
+        compact: options.compact === true ? true : undefined,
+    };
+}
+export function resolveActivityStreamMode(raw) {
+    if (raw === true) {
+        return true;
+    }
+    if (raw === false || raw === undefined || raw === null) {
+        return false;
+    }
+    if (typeof raw === "string") {
+        const normalized = raw.trim().toLowerCase();
+        if (normalized.length === 0 ||
+            normalized === "rows" ||
+            normalized === "ndjson" ||
+            normalized === "jsonl" ||
+            normalized === "true" ||
+            normalized === "1" ||
+            normalized === "yes" ||
+            normalized === "on") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "off" || normalized === "none" || normalized === "0") {
+            return false;
+        }
+    }
+    throw new PmCliError("Activity --stream accepts rows|ndjson|jsonl (or no value)", EXIT_CODE.USAGE);
+}
+export function normalizeContextOptions(options) {
+    const readContextString = (target) => readFirstStringFromCommanderOptions(options, CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS.find((entry) => entry.target === target) ?? {
+        target,
+        keys: [target],
+    });
+    const sectionRaw = options.section;
+    const section = Array.isArray(sectionRaw)
+        ? sectionRaw.filter((v) => typeof v === "string" && v.trim().length > 0)
+        : typeof sectionRaw === "string" && sectionRaw.trim().length > 0
+            ? [sectionRaw]
+            : undefined;
+    const normalized = {
+        date: readContextString("date"),
+        from: readContextString("from"),
+        to: readContextString("to"),
+        past: options.past === true ? true : undefined,
+        type: readContextString("type"),
+        tag: readContextString("tag"),
+        priority: readContextString("priority"),
+        assignee: readContextString("assignee"),
+        assigneeFilter: readContextString("assigneeFilter"),
+        sprint: readContextString("sprint"),
+        release: readContextString("release"),
+        limit: readContextString("limit"),
+        format: readContextString("format"),
+        depth: readContextString("depth"),
+        section: section && section.length > 0 ? section : undefined,
+        activityLimit: readContextString("activityLimit"),
+        staleThreshold: readContextString("staleThreshold"),
+    };
+    for (const [key, value] of Object.entries(options)) {
+        if (Object.hasOwn(normalized, key)) {
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+function collectMutationItemIds(result) {
+    if (!result || typeof result !== "object") {
+        return [];
+    }
+    const record = result;
+    const ids = new Set();
+    const pushId = (value) => {
+        if (typeof value !== "string") {
+            return;
+        }
+        const normalized = value.trim();
+        if (normalized.length === 0) {
+            return;
+        }
+        ids.add(normalized);
+    };
+    pushId(record.id);
+    const item = record.item;
+    if (item && typeof item === "object") {
+        pushId(item.id);
+    }
+    const explicitIds = record.ids;
+    if (Array.isArray(explicitIds)) {
+        for (const candidate of explicitIds) {
+            pushId(candidate);
+        }
+    }
+    const items = record.items;
+    if (Array.isArray(items)) {
+        for (const candidate of items) {
+            if (!candidate || typeof candidate !== "object") {
+                continue;
+            }
+            pushId(candidate.id);
+        }
+    }
+    return [...ids].sort((left, right) => left.localeCompare(right));
+}
+export async function invalidateSearchCachesForMutation(globalOptions, result) {
+    const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+    const refreshResult = await refreshSearchArtifactsForMutation(pmRoot, collectMutationItemIds(result));
+    if (globalOptions.profile && refreshResult.warnings.length > 0) {
+        printError(`profile:search_refresh_warnings=${formatHookWarnings(refreshResult.warnings)}`);
+    }
+}
+//# sourceMappingURL=registration-helpers.js.map