@unbrained/pm-cli 2026.5.14 → 2026.5.24

package/dist/cli/main.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
+
+!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]="bb46ecaf-3f2f-526b-b6fa-4d87511ede62")}catch(e){}}();
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { activateExtensions, clearActiveExtensionHooks, getActiveCommandResult, getActiveExtensionRegistrations, loadExtensions, runActiveCommandHandler, runActiveParserOverride, runActivePreflightOverride, runAfterCommandHooks, runBeforeCommandHooks, setActiveCommandResult, setActiveCommandContext, setActiveExtensionCommands, setActiveExtensionHooks, setActiveExtensionParsers, setActiveExtensionPreflight, setActiveExtensionRegistrations, setActiveExtensionRenderers, setActiveExtensionServices, } from "../core/extensions/index.js";
 import { pathExists } from "../core/fs/fs-utils.js";
+import { resolvePmPackageRootFromModule } from "../core/packages/root.js";
 import { resolveItemTypeRegistry, } from "../core/item/type-registry.js";
 import { resolveRuntimeFieldRegistry, } from "../core/schema/runtime-schema.js";
 import { EXIT_CODE, resolveTelemetryErrorCategory } from "../core/shared/constants.js";
@@ -17,15 +19,12 @@ import { sentryCaptureCliError, sentryFinishCommandSpan, sentryFlush, sentryLogC
 import { ensureSentryInit } from "../core/sentry/instrument.js";
 import { getSettingsPath, resolvePmRoot } from "../core/store/paths.js";
 import { readSettings } from "../core/store/settings.js";
-import { coerceLooseCommandOptionsWithFlagDefinitions, parseLooseCommandOptions } from "./extension-command-options.js";
+import { coerceLooseCommandOptionsWithFlagDefinitions, parseLooseCommandOptions, validateLooseCommandOptionsWithFlagDefinitions, } from "./extension-command-options.js";
 import { attachRichHelpText } from "./help-content.js";
 import { extractProvidedOptionFlags, normalizeLongOptionFlag, renderPmCommand, } from "./argv-utils.js";
 import { classifyCommanderError, classifyPmCliError, classifyUnknownError, formatPmCliErrorForDisplay, formatPmCliErrorForJson, formatUnknownErrorForJson, } from "./error-guidance.js";
 import { applyDefaultOutputFormat, clearResolvedGlobalOptions, collect, formatHookWarnings, getCommandPath, getGlobalOptions, invalidateSearchCachesForMutation, setResolvedGlobalOptions, } from "./registration-helpers.js";
-import { registerSetupCommands } from "./register-setup.js";
-import { registerListQueryCommands } from "./register-list-query.js";
-import { registerMutationCommands } from "./register-mutation.js";
-import { registerOperationCommands } from "./register-operations.js";
+import { createLazyModule } from "../core/shared/lazy-module.js";
 import { normalizeExtensionCommandPath, collectDynamicExtensionFlagHelpByCommand, collectExtensionCommandHelpDescriptors, applyDynamicExtensionArguments, buildDynamicExtensionCommandMetadataHelp, findCommandByPath, ensureCommandPath, } from "./extension-command-help.js";
 import { parseBootstrapGlobalOptions, applyBootstrapPagerPolicy, parseBootstrapHelpRequest, parseBootstrapCommandName, normalizeBootstrapInvocation, } from "./bootstrap-args.js";
 import { collectMandatoryMigrationBlockers, enforceMandatoryMigrationWriteGate, enforceItemFormatWriteGateAndPreflightMigration, resolveMigrationId, resolveNormalizedMigrationStatus, } from "./migration-gates.js";
@@ -33,8 +32,7 @@ import { isKnownHelpCommandPath, formatCommanderUsageMessage, formatCommanderUsa
 import { maybeRenderBootstrapJsonHelp, attachCreateUpdatePolicyHelpText, } from "./help-json-payload.js";
 const PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
 function resolvePmPackageRoot() {
-    const mainPath = fileURLToPath(import.meta.url);
-    return path.resolve(path.dirname(mainPath), "../..");
+    return resolvePmPackageRootFromModule(import.meta.url, ["../.."]);
 }
 if (typeof process.env[PM_PACKAGE_ROOT_ENV] !== "string" || process.env[PM_PACKAGE_ROOT_ENV]?.trim().length === 0) {
     process.env[PM_PACKAGE_ROOT_ENV] = resolvePmPackageRoot();
@@ -49,6 +47,8 @@ const TELEMETRY_COMMAND_RESOLUTION_SET = new Set([
     "missing_required_argument",
     "invalid_usage",
     "validation_failed",
+    "health_findings",
+    "validation_findings",
     "conflict",
     "runtime_failed",
     "unknown_failed",
@@ -57,6 +57,10 @@ const TELEMETRY_RESOLUTION_STAGE_SET = new Set(["parse", "preflight", "execute",
 const TELEMETRY_ERROR_CATEGORY_SET = new Set(["usage", "validation", "conflict", "runtime", "unknown"]);
 let runtimeExtensionSnapshotCache = null;
 let activeRuntimeExtensionCommandDescriptors = new Map();
+const loadSetupRegistrationModule = createLazyModule(() => import("./register-setup.js"));
+const loadListQueryRegistrationModule = createLazyModule(() => import("./register-list-query.js"));
+const loadMutationRegistrationModule = createLazyModule(() => import("./register-mutation.js"));
+const loadOperationRegistrationModule = createLazyModule(() => import("./register-operations.js"));
 function describeUnknownError(error) {
     if (error instanceof PmCliError) {
         return error.message;
@@ -80,28 +84,31 @@ function inferMissingFieldsFromErrorMessage(message) {
 function buildPmCliRecoveryContext(context, invocationArgv, rawMessage) {
     const attemptedCommand = renderAttemptedCommand(invocationArgv);
     const providedFields = extractProvidedOptionFlags(invocationArgv);
-    const inferredMissing = inferMissingFieldsFromErrorMessage(rawMessage);
+    const providedSet = new Set(providedFields.map((flag) => normalizeLongOptionFlag(flag) ?? flag));
     const existingRecovery = context?.recovery;
+    const rawInferred = existingRecovery?.suggested_retry ? undefined : inferMissingFieldsFromErrorMessage(rawMessage);
+    const trulyMissing = rawInferred?.filter((flag) => !providedSet.has(normalizeLongOptionFlag(flag) ?? flag));
+    const inferredMissing = trulyMissing && trulyMissing.length > 0 ? trulyMissing : undefined;
     let suggestedRetry = existingRecovery?.suggested_retry;
     if (!suggestedRetry && inferredMissing && inferredMissing.length > 0) {
         const missingFlag = inferredMissing[0];
         const normalizedMissing = normalizeLongOptionFlag(missingFlag);
         if (normalizedMissing) {
-            const alreadyProvided = invocationArgv.some((token) => normalizeLongOptionFlag(token) === normalizedMissing);
-            if (!alreadyProvided) {
-                suggestedRetry = renderAttemptedCommand([...invocationArgv, normalizedMissing, "<value>"]);
-            }
+            suggestedRetry = renderAttemptedCommand([...invocationArgv, normalizedMissing, "<value>"]);
         }
     }
     if (!suggestedRetry) {
         suggestedRetry = attemptedCommand;
     }
+    if (suggestedRetry === attemptedCommand) {
+        suggestedRetry = undefined;
+    }
     const recovery = {
         attempted_command: existingRecovery?.attempted_command ?? attemptedCommand,
         normalized_args: existingRecovery?.normalized_args ?? [...invocationArgv],
         provided_fields: existingRecovery?.provided_fields ?? (providedFields.length > 0 ? providedFields : undefined),
         missing: existingRecovery?.missing ?? inferredMissing,
-        suggested_retry: suggestedRetry,
+        ...(suggestedRetry ? { suggested_retry: suggestedRetry } : {}),
     };
     return {
         ...(context ?? {}),
@@ -240,8 +247,7 @@ function buildPostActionTelemetryOutcome() {
         : undefined;
     const resultExitCode = readRecordNumber(result, "exit_code", "exitCode");
     const exitCode = processExitCode ?? resultExitCode ?? EXIT_CODE.SUCCESS;
-    const resultOk = readRecordBoolean(result, "ok");
-    const ok = resultOk ?? exitCode === EXIT_CODE.SUCCESS;
+    const ok = exitCode === EXIT_CODE.SUCCESS;
     const errorCode = readRecordString(result, "error_code", "errorCode") ?? inferPostActionErrorCode(ok, exitCode);
     const errorCategory = normalizeTelemetryErrorCategory(readRecordString(result, "error_category", "errorCategory")) ??
         (!ok ? resolveTelemetryErrorCategory(errorCode) : undefined);
@@ -313,6 +319,9 @@ function extractCommandScopedOptions(command, commandArgs, extensionFlagDefiniti
     delete scoped.profile;
     delete scoped.pager;
     const looseOptions = parseLooseCommandOptions(commandArgs);
+    if (extensionFlagDefinitions.length > 0) {
+        validateLooseCommandOptionsWithFlagDefinitions(looseOptions, extensionFlagDefinitions, getCommandPath(command));
+    }
     for (const [key, value] of Object.entries(looseOptions)) {
         if (scoped[key] === undefined) {
             scoped[key] = value;
@@ -332,6 +341,22 @@ function collectExtensionFlagDefinitionsForCommand(registrations, commandPath) {
         .filter((entry) => normalizeExtensionCommandPath(entry.target_command) === normalizedCommandPath)
         .flatMap((entry) => entry.flags);
 }
+function collectExtensionFlagDefinitionsForInvocation(registrations, commandPath, commandArgs) {
+    const exact = collectExtensionFlagDefinitionsForCommand(registrations, commandPath);
+    const pathParts = [commandPath];
+    let nestedMatch = [];
+    for (const arg of commandArgs) {
+        if (arg.startsWith("-")) {
+            break;
+        }
+        pathParts.push(arg);
+        const nested = collectExtensionFlagDefinitionsForCommand(registrations, pathParts.join(" "));
+        if (nested.length > 0) {
+            nestedMatch = nested;
+        }
+    }
+    return nestedMatch.length > 0 ? nestedMatch : exact;
+}
 const RUNTIME_FIELD_COMMAND_BY_COMMAND_PATH = {
     create: "create",
     update: "update",
@@ -663,7 +688,7 @@ function wrapProgramActionsForExtensionHandlers(rootProgram) {
                 let commandArgs = actionCommand.args.map(String);
                 const activeRegistrations = getActiveExtensionRegistrations();
                 const extensionFlagDefinitions = activeRegistrations
-                    ? collectExtensionFlagDefinitionsForCommand(activeRegistrations, commandPath)
+                    ? collectExtensionFlagDefinitionsForInvocation(activeRegistrations, commandPath, commandArgs)
                     : [];
                 const runtimeFieldFlagDefinitions = await collectRuntimeFieldLooseFlagDefinitionsForCommand(commandPath, pmRoot);
                 let commandOptions = extractCommandScopedOptions(actionCommand, commandArgs, [
@@ -715,7 +740,13 @@ function wrapProgramActionsForExtensionHandlers(rootProgram) {
                 }
                 if (extensionCommandResult.handled) {
                     setActiveCommandResult(extensionCommandResult.result);
-                    printResult(extensionCommandResult.result, globalOptions);
+                    printResult(extensionCommandResult.result, {
+                        ...globalOptions,
+                        command: commandPath,
+                        commandArgs,
+                        commandOptions,
+                        pmRoot,
+                    });
                     if (globalOptions.profile) {
                         printError(`profile:command=${commandPath} took_ms=${Date.now() - startedAt}`);
                     }
@@ -789,14 +820,22 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
         dynamicCommand
             .allowUnknownOption(true)
             .allowExcessArguments(true)
-            .action(async (_options, command) => {
+            .action(async (...actionArgs) => {
+            const maybeCommand = actionArgs[actionArgs.length - 1];
+            const command = maybeCommand instanceof Command ? maybeCommand : dynamicCommand;
             const globalOptions = getGlobalOptions(command);
             const startedAt = Date.now();
-            const extensionFlagDefinitions = collectExtensionFlagDefinitionsForCommand(snapshot.registrations, commandPath);
+            const extensionFlagDefinitions = collectExtensionFlagDefinitionsForInvocation(snapshot.registrations, commandPath, command.args.map(String));
             const scopedOptions = extractCommandScopedOptions(command, command.args.map(String), extensionFlagDefinitions);
             const result = await runRequiredExtensionCommand(command, scopedOptions, globalOptions);
             await invalidateSearchCachesForMutation(globalOptions, result);
-            printResult(result, globalOptions);
+            printResult(result, {
+                ...globalOptions,
+                command: commandPath,
+                commandArgs: command.args.map(String),
+                commandOptions: scopedOptions,
+                pmRoot,
+            });
             if (globalOptions.profile) {
                 printError(`profile:command=${commandPath} took_ms=${Date.now() - startedAt}`);
             }
@@ -805,8 +844,7 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
 }
 function resolveCliVersion() {
     try {
-        const currentFilePath = fileURLToPath(import.meta.url);
-        const packageJsonPath = path.resolve(path.dirname(currentFilePath), "../../package.json");
+        const packageJsonPath = path.join(resolvePmPackageRoot(), "package.json");
         const raw = fs.readFileSync(packageJsonPath, "utf8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : "0.0.0";
@@ -876,7 +914,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
     setActiveExtensionServices(runtimeExtensions.services);
     setActiveExtensionRenderers(runtimeExtensions.renderers);
     setActiveExtensionRegistrations(runtimeExtensions.registrations);
-    const extensionFlagDefinitions = collectExtensionFlagDefinitionsForCommand(runtimeExtensions.registrations, commandPath);
+    const extensionFlagDefinitions = collectExtensionFlagDefinitionsForInvocation(runtimeExtensions.registrations, commandPath, commandArgs);
     commandOptions = extractCommandScopedOptions(actionCommand, commandArgs, extensionFlagDefinitions);
     const parserOverride = await runActiveParserOverride({
         command: commandPath,
@@ -970,11 +1008,73 @@ program.hook("postAction", async () => {
     });
     await runAndClearAfterCommandHooks(outcome);
 });
-registerSetupCommands(program);
-registerListQueryCommands(program);
-registerMutationCommands(program);
-registerOperationCommands(program);
 const VERSION_FLAG_TOKENS = new Set(["--version", "-V"]);
+const SETUP_COMMAND_NAMES = new Set([
+    "config",
+    "extension",
+    "init",
+    "install",
+    "package",
+    "packages",
+    "templates",
+    "upgrade",
+]);
+const LIST_QUERY_COMMAND_NAMES = new Set([
+    "activity",
+    "aggregate",
+    "context",
+    "ctx",
+    "get",
+    "history",
+    "list",
+    "list-all",
+    "list-blocked",
+    "list-canceled",
+    "list-closed",
+    "list-draft",
+    "list-in-progress",
+    "list-open",
+    "search",
+]);
+const MUTATION_COMMAND_NAMES = new Set([
+    "append",
+    "close",
+    "comments",
+    "delete",
+    "deps",
+    "discover",
+    "docs",
+    "files",
+    "learnings",
+    "notes",
+    "plan",
+    "restore",
+    "update",
+    "update-many",
+    "create",
+]);
+const OPERATION_COMMAND_NAMES = new Set([
+    "claim",
+    "close-task",
+    "contracts",
+    "gc",
+    "health",
+    "pause-task",
+    "release",
+    "start-task",
+    "stats",
+    "test",
+    "test-all",
+    "test-runs",
+    "test-runs-worker",
+    "validate",
+]);
+const REGISTER_ALL_CORE_COMMAND_FAMILIES = {
+    setup: true,
+    listQuery: true,
+    mutation: true,
+    operation: true,
+};
 const RUNTIME_SCHEMA_FLAG_BOOTSTRAP_COMMANDS = new Set([
     "create",
     "update",
@@ -995,6 +1095,80 @@ const RUNTIME_SCHEMA_FLAG_BOOTSTRAP_COMMANDS = new Set([
 function invocationRequestsVersion(invocationArgv) {
     return invocationArgv.some((token) => VERSION_FLAG_TOKENS.has(token));
 }
+function resolveCoreCommandRegistrationSelection(invocationArgv) {
+    if (invocationRequestsVersion(invocationArgv)) {
+        return {
+            setup: false,
+            listQuery: false,
+            mutation: false,
+            operation: false,
+        };
+    }
+    if (invocationArgv.length === 0 ||
+        parseBootstrapHelpRequest(invocationArgv).requested) {
+        return REGISTER_ALL_CORE_COMMAND_FAMILIES;
+    }
+    const commandName = parseBootstrapCommandName(invocationArgv);
+    if (!commandName) {
+        return REGISTER_ALL_CORE_COMMAND_FAMILIES;
+    }
+    const normalizedCommand = commandName.trim().toLowerCase();
+    if (SETUP_COMMAND_NAMES.has(normalizedCommand)) {
+        return {
+            setup: true,
+            listQuery: false,
+            mutation: false,
+            operation: false,
+        };
+    }
+    if (LIST_QUERY_COMMAND_NAMES.has(normalizedCommand)) {
+        return {
+            setup: false,
+            listQuery: true,
+            mutation: false,
+            operation: false,
+        };
+    }
+    if (MUTATION_COMMAND_NAMES.has(normalizedCommand)) {
+        return {
+            setup: false,
+            listQuery: false,
+            mutation: true,
+            operation: false,
+        };
+    }
+    if (OPERATION_COMMAND_NAMES.has(normalizedCommand)) {
+        return {
+            setup: false,
+            listQuery: false,
+            mutation: false,
+            operation: true,
+        };
+    }
+    return REGISTER_ALL_CORE_COMMAND_FAMILIES;
+}
+function shouldAttachRichHelpTextForInvocation(invocationArgv) {
+    return (invocationArgv.length === 0 ||
+        parseBootstrapHelpRequest(invocationArgv).requested);
+}
+async function registerCoreCommandFamilies(rootProgram, selection) {
+    if (selection.setup) {
+        const { registerSetupCommands } = await loadSetupRegistrationModule();
+        registerSetupCommands(rootProgram);
+    }
+    if (selection.listQuery) {
+        const { registerListQueryCommands } = await loadListQueryRegistrationModule();
+        registerListQueryCommands(rootProgram);
+    }
+    if (selection.mutation) {
+        const { registerMutationCommands } = await loadMutationRegistrationModule();
+        registerMutationCommands(rootProgram);
+    }
+    if (selection.operation) {
+        const { registerOperationCommands } = await loadOperationRegistrationModule();
+        registerOperationCommands(rootProgram);
+    }
+}
 function isKnownTopLevelCommandOrAlias(rootProgram, commandName) {
     const normalized = commandName.trim().toLowerCase();
     for (const command of rootProgram.commands) {
@@ -1032,12 +1206,17 @@ function shouldRegisterRuntimeSchemaFlags(invocationArgv) {
     return RUNTIME_SCHEMA_FLAG_BOOTSTRAP_COMMANDS.has(commandName);
 }
 const bootstrapInvocation = normalizeBootstrapInvocation(process.argv.slice(2));
-attachRichHelpText(program, bootstrapInvocation.argv);
 async function main() {
     const invocationArgv = bootstrapInvocation.argv;
     const invocationProcessArgv = [process.argv[0], process.argv[1], ...invocationArgv];
+    const isBareInvocation = invocationArgv.length === 0;
     try {
         applyBootstrapPagerPolicy(invocationArgv);
+        const registrationSelection = resolveCoreCommandRegistrationSelection(invocationArgv);
+        await registerCoreCommandFamilies(program, registrationSelection);
+        if (shouldAttachRichHelpTextForInvocation(invocationArgv)) {
+            attachRichHelpText(program, invocationArgv);
+        }
         const registerDynamicCommands = shouldRegisterDynamicExtensionPaths(program, invocationArgv);
         if (registerDynamicCommands) {
             await registerDynamicExtensionCommandPaths(program, invocationArgv);
@@ -1054,6 +1233,10 @@ async function main() {
         if (renderedBootstrapJsonHelp) {
             return;
         }
+        if (isBareInvocation) {
+            program.outputHelp();
+            return;
+        }
         await program.parseAsync(invocationProcessArgv);
     }
     catch (error) {
@@ -1345,4 +1528,5 @@ async function main() {
     }
 }
 void main();
-//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map
+//# debugId=bb46ecaf-3f2f-526b-b6fa-4d87511ede62