@detergent-software/atk 8.9.0-dev.3 → 8.9.0-dev.5

package/build/lib/publish-flow.js

@@ -10,7 +10,7 @@ import { addAssetToLockfile, findInstalledAsset, readLockfile, withLockfileLock,
 import { diffManifests, fetchExistingManifest } from './manifest-diff.js';
 import { parseOrgFromName } from './org.js';
 import { findProjectRoot } from './paths.js';
-import { buildPublishPlan, buildStagingArea, checkRegistryVersion, detectAssetFromPath, detectPublishType, executePublish, findSiblingDependencies, loadPublishBatch, loadPublishEntries, mapPublishError, missingDependencies, resolvePlanDependencies, unknownToolsError, updateManifestField, updateManifestVersion, validatePublishTarget, } from './publisher.js';
+import { buildPublishPlan, buildStagingArea, bumpVersion, checkRegistryVersion, detectAssetFromPath, detectPublishType, executePublish, findSiblingDependencies, isOrgScopedTarget, loadPublishBatch, loadPublishEntries, mapPublishError, missingDependencies, resolvePlanDependencies, unknownToolsError, updateManifestField, updateManifestVersion, validatePublishTarget, } from './publisher.js';
 import { clearCache, fetchAssetManifest, fetchRegistry, findAsset, findBundle } from './registry.js';
 import { parseReviewersInput, validateGithubUsername } from './reviewers.js';
 import { stageInstalledFiles } from './staging.js';
@@ -63,7 +63,6 @@ export function createInitialState(flags) {
         target: undefined,
         token: undefined,
         toolAdapters: [],
-        toolCursorIndex: 0,
         toolsDetected: [],
         validation: undefined,
         versionCheck: undefined,
@@ -799,4 +798,508 @@ const installing = {
         ctx.dispatch({ type: 'INSTALL_DONE' });
     },
 };
+// ---------------------------------------------------------------------------
+// Reducer
+// ---------------------------------------------------------------------------
+export function publishReducer(state, action) {
+    switch (action.type) {
+        case 'BUMP_DONE': {
+            const bumped = {
+                ...state,
+                errorMessage: action.message ? action.message : state.errorMessage,
+                resolvedVersion: action.version,
+                target: action.updatedTarget,
+            };
+            return action.message ? { ...bumped, phase: 'error' } : advanceToPlan(bumped);
+        }
+        case 'CONFIRM_PROMPT_TOOLS': {
+            if (action.tools.length === 0)
+                return state;
+            const updatedToolsTarget = state.target
+                ? {
+                    ...state.target,
+                    data: { ...state.target.data, tools: action.tools },
+                }
+                : undefined;
+            return {
+                ...state,
+                phase: phaseAfterMetadata(updatedToolsTarget),
+                selectedPromptTools: action.tools,
+                target: updatedToolsTarget,
+            };
+        }
+        case 'DETECT_DONE':
+            if (action.target.type === 'bundle' && state.entries.length > 0) {
+                return {
+                    ...state,
+                    errorMessage: 'A bundle is published on its own. Remove --with, and publish its new assets first.',
+                    phase: 'error',
+                    target: action.target,
+                };
+            }
+            return {
+                ...state,
+                phase: 'validating',
+                target: action.target,
+            };
+        case 'ENTRIES_CHECKED':
+            return advanceToPlan({ ...state, entries: action.entries });
+        case 'ENTRIES_LOADED':
+            return { ...state, entries: action.entries };
+        case 'ERROR':
+            return {
+                ...state,
+                errorCode: action.code,
+                errorCommand: action.command,
+                errorHint: action.hint,
+                errorMessage: action.message,
+                phase: 'error',
+            };
+        case 'INSTALL_DONE':
+            return { ...state, phase: 'done' };
+        case 'PLAN_DONE': {
+            // dry-run always shows the dry-run result; --yes / non-TTY skip the confirm prompt
+            // and proceed directly to publishing.
+            let nextPhase;
+            if (state.flags.dryRun) {
+                nextPhase = 'dry-run-result';
+            }
+            else if (state.nonInteractive) {
+                nextPhase = 'publishing';
+            }
+            else {
+                nextPhase = 'confirm-publish';
+            }
+            return {
+                ...state,
+                manifestDiff: action.manifestDiff,
+                phase: nextPhase,
+                plan: action.plan,
+            };
+        }
+        case 'PUBLISH_DONE': {
+            const nextPhase = state.isRawPublish ? 'installing' : 'done';
+            return {
+                ...state,
+                phase: nextPhase,
+                publishResult: action.result,
+            };
+        }
+        case 'PUBLISH_PROGRESS':
+            return { ...state, progressMessage: action.message };
+        case 'RAW_DETECT_DONE':
+            return {
+                ...state,
+                authorValue: action.authorValue,
+                isRawPublish: true,
+                orgValue: action.orgValue,
+                phase: 'gathering-metadata',
+                rawDetection: action.rawDetection,
+                toolsDetected: action.toolsDetected,
+            };
+        case 'RAW_DETECT_DONE_NON_INTERACTIVE':
+            return {
+                ...state,
+                isRawPublish: true,
+                phase: 'validating',
+                rawDetection: action.rawDetection,
+                target: action.target,
+            };
+        case 'REGISTRY_CHECK_DONE': {
+            const { isUpdate, resolvedVersion, token, versionCheck } = action;
+            let nextPhase;
+            let errorMessage = state.errorMessage;
+            let bumpedVersion = resolvedVersion;
+            let bumpedTarget = state.target;
+            if (versionCheck.status === 'new-asset') {
+                nextPhase = 'building-plan';
+            }
+            else if (versionCheck.status === 'version-already-bumped') {
+                // --yes / non-TTY implicitly confirm the update
+                nextPhase = state.nonInteractive ? 'building-plan' : 'confirm-update';
+            }
+            else {
+                // needs-bump
+                if (state.nonInteractive) {
+                    if (state.flags.bump && state.target) {
+                        // Auto-bump using the flag value; a successful publish writes it to the manifest
+                        try {
+                            bumpedVersion = bumpVersion(versionCheck.latestVersion, state.flags.bump);
+                            bumpedTarget = {
+                                ...state.target,
+                                data: { ...state.target.data, version: bumpedVersion },
+                            };
+                            nextPhase = 'building-plan';
+                        }
+                        catch {
+                            errorMessage = 'Failed to compute bumped version.';
+                            nextPhase = 'error';
+                        }
+                    }
+                    else if (isBatch(state.flags)) {
+                        // advanceToPlan lists every asset of the batch that needs --bump, once the entries are checked.
+                        nextPhase = 'building-plan';
+                    }
+                    else {
+                        errorMessage = `--bump <patch|minor|major> required: registry has v${versionCheck.latestVersion} but manifest is not newer`;
+                        nextPhase = 'error';
+                    }
+                }
+                else {
+                    nextPhase = 'bump-prompt';
+                }
+            }
+            const checked = {
+                ...state,
+                errorMessage,
+                isUpdate,
+                phase: nextPhase,
+                resolvedVersion: bumpedVersion,
+                target: bumpedTarget,
+                token,
+                versionCheck,
+            };
+            return nextPhase === 'building-plan' ? advanceToPlan(checked) : checked;
+        }
+        case 'RESOLVE_TOOLS_NONINTERACTIVE': {
+            const updatedTarget = state.target
+                ? {
+                    ...state.target,
+                    data: { ...state.target.data, tools: action.tools },
+                }
+                : undefined;
+            return {
+                ...state,
+                phase: 'checking-registry',
+                target: updatedTarget,
+            };
+        }
+        case 'RESOLVED_INSTALLED':
+            return {
+                ...state,
+                phase: 'detecting',
+                resolvedPath: action.resolvedPath,
+            };
+        case 'RESOLVED_UPDATE':
+            return {
+                ...state,
+                phase: 'detecting',
+                resolvedPath: action.resolvedPath,
+            };
+        case 'SET_BUMP_SELECTION':
+            return { ...state, bumpSelection: action.value };
+        case 'SET_CONFIRM_VALUE':
+            return { ...state, confirmValue: action.value };
+        case 'SET_DESCRIPTION':
+            return { ...state, descriptionValue: action.value };
+        case 'SET_PROMPT_TAGS':
+            return { ...state, promptTagsValue: action.value };
+        case 'SET_PUBLISH_CONFIRM_VALUE':
+            return { ...state, publishConfirmValue: action.value };
+        case 'SET_REVIEWER':
+            return { ...state, reviewerValue: action.value };
+        case 'SET_TAGS':
+            return { ...state, tagsValue: action.value };
+        case 'SET_WITH_CONFIRM_VALUE':
+            return { ...state, withConfirmValue: action.value };
+        case 'STAGING_DONE':
+            return {
+                ...state,
+                phase: 'validating',
+                target: action.target,
+            };
+        case 'SUBMIT_BUMP': {
+            const trimmed = state.bumpSelection.trim().toLowerCase();
+            if (trimmed !== 'patch' && trimmed !== 'minor' && trimmed !== 'major') {
+                return state; // Ignore invalid input
+            }
+            // The prompt is for an entry: bump it, then on to the next pending bump or the plan.
+            if (state.bumpEntry !== undefined) {
+                const entry = state.entries[state.bumpEntry];
+                if (entry?.versionCheck?.status !== 'needs-bump')
+                    return state;
+                return bumpEntryAt({ ...state, bumpSelection: '' }, state.bumpEntry, trimmed);
+            }
+            if (!state.target || !state.versionCheck || state.versionCheck.status !== 'needs-bump') {
+                return state;
+            }
+            // Compute the bumped version in the reducer (pure, synchronous)
+            const bumpType = trimmed;
+            try {
+                const newVersion = bumpVersion(state.versionCheck.latestVersion, bumpType);
+                // The bump is only on the target until the publish succeeds, which writes it to
+                // the manifest; entries still to check or bump come first.
+                return advanceToPlan({
+                    ...state,
+                    bumpSelection: '',
+                    resolvedVersion: newVersion,
+                    target: { ...state.target, data: { ...state.target.data, version: newVersion } },
+                });
+            }
+            catch {
+                return {
+                    ...state,
+                    errorMessage: 'Failed to compute bumped version.',
+                    phase: 'error',
+                };
+            }
+        }
+        case 'SUBMIT_CONFIRM': {
+            const trimmed = state.confirmValue.trim().toLowerCase();
+            if (trimmed === 'y' || trimmed === 'yes') {
+                return advanceToPlan(state);
+            }
+            else if (trimmed === 'n' || trimmed === 'no') {
+                return { ...state, errorMessage: 'Publish cancelled.', phase: 'error' };
+            }
+            // Otherwise ignore (wait for valid input)
+            return state;
+        }
+        case 'SUBMIT_DESCRIPTION': {
+            const trimmed = state.descriptionValue.trim();
+            if (!trimmed)
+                return state; // Don't allow empty description
+            return {
+                ...state,
+                descriptionValue: trimmed,
+                metadataSubPhase: 'tags',
+            };
+        }
+        case 'SUBMIT_PROMPT_TAGS': {
+            const parsedTags = splitList(state.promptTagsValue);
+            // Update the target's data with the new tags
+            const updatedTagsTarget = state.target
+                ? {
+                    ...state.target,
+                    data: { ...state.target.data, tags: parsedTags.length > 0 ? parsedTags : undefined },
+                }
+                : undefined;
+            // Check if tools are also missing (only for assets)
+            const needsToolsPrompt = updatedTagsTarget?.type === 'asset' &&
+                (!('tools' in updatedTagsTarget.data) ||
+                    !Array.isArray(updatedTagsTarget.data.tools) ||
+                    (updatedTagsTarget.data.tools?.length ?? 0) === 0);
+            const nextTagsPhase = needsToolsPrompt ? 'loading-tools' : phaseAfterMetadata(updatedTagsTarget);
+            return {
+                ...state,
+                phase: nextTagsPhase,
+                target: updatedTagsTarget,
+            };
+        }
+        case 'SUBMIT_PUBLISH_CONFIRM': {
+            const trimmed = state.publishConfirmValue.trim().toLowerCase();
+            if (trimmed === 'y' || trimmed === 'yes') {
+                return { ...state, phase: 'publishing' };
+            }
+            else if (trimmed === 'n' || trimmed === 'no') {
+                return { ...state, errorMessage: 'Publish cancelled.', phase: 'error' };
+            }
+            // Otherwise ignore (wait for valid input)
+            return state;
+        }
+        case 'SUBMIT_REVIEWER':
+            return { ...state, phase: 'checking-registry' };
+        case 'SUBMIT_TAGS':
+            return {
+                ...state,
+                metadataSubPhase: 'building-staging',
+            };
+        case 'SUBMIT_WITH_CONFIRM': {
+            const trimmed = state.withConfirmValue.trim().toLowerCase();
+            if (trimmed === 'y' || trimmed === 'yes') {
+                return advanceToPlan({
+                    ...state,
+                    entries: [...state.entries, ...state.suggestedEntries],
+                    missingDependencies: [],
+                    pendingError: undefined,
+                    suggestedEntries: [],
+                    withConfirmValue: '',
+                });
+            }
+            if ((trimmed === 'n' || trimmed === 'no') && state.pendingError) {
+                return publishReducer({ ...state, suggestedEntries: [], withConfirmValue: '' }, state.pendingError);
+            }
+            return state;
+        }
+        case 'SUGGEST_ENTRIES':
+            return {
+                ...state,
+                missingDependencies: action.missing,
+                pendingError: action.error,
+                phase: 'confirm-with',
+                suggestedEntries: action.suggested,
+                withConfirmValue: '',
+            };
+        case 'TOOLS_LOADED':
+            return {
+                ...state,
+                phase: 'prompting-tools',
+                toolAdapters: action.adapters,
+            };
+        case 'VALIDATE_DONE': {
+            if (!action.validation.valid) {
+                return {
+                    ...state,
+                    errorMessage: `Validation failed:\n${action.validation.errors.map((e) => `  - ${e}`).join('\n')}`,
+                    phase: 'error',
+                    validation: action.validation,
+                };
+            }
+            // Seed the reviewers field: the --reviewer flag wins over the project's
+            // lockfile-configured default (org.ts's CLI-flag > lockfile priority chain).
+            const reviewerValue = state.flags.reviewerFlag ?? (action.lockfileOrgReviewers ?? []).join(', ');
+            // Determine next phase based on missing tags/tools. A batch asks for neither: as for
+            // a --with entry, a missing one is only a warning.
+            const batch = isBatch(state.flags);
+            const manifest = state.target?.data;
+            const hasTags = batch || (manifest && 'tags' in manifest && Array.isArray(manifest.tags) && manifest.tags.length > 0);
+            const hasTools = batch ||
+                // Only assets have tools; bundles skip the tools prompt
+                state.target?.type !== 'asset' ||
+                (manifest && 'tools' in manifest && Array.isArray(manifest.tools) && manifest.tools.length > 0);
+            const isOrgScoped = batch
+                ? [state.target, ...state.entries.map((entry) => entry.target)].some((t) => t && isOrgScopedTarget(t))
+                : Boolean(state.target && isOrgScopedTarget(state.target));
+            // Reviewers only apply to org-scoped assets (non-org PRs always go to the registry
+            // maintainer) — fail fast rather than silently ignoring the flag.
+            if (!isOrgScoped && state.flags.reviewerFlag && parseReviewersInput(state.flags.reviewerFlag).length > 0) {
+                return {
+                    ...state,
+                    errorMessage: 'The --reviewer flag only applies to org-scoped assets. Remove the flag to publish this asset.',
+                    phase: 'error',
+                    validation: action.validation,
+                };
+            }
+            // Non-interactive path: resolve tags from --tags flag (or empty) right here, then
+            // either route to loading-tools (effect resolves tools async) or directly to
+            // checking-registry. Manifest tags always win when present. The reviewer prompt
+            // never applies here — non-interactive mode always skips it.
+            if (state.nonInteractive) {
+                let nextTarget = state.target;
+                if (!hasTags && nextTarget) {
+                    const flagTags = splitList(state.flags.tagsFlag);
+                    nextTarget = {
+                        ...nextTarget,
+                        data: { ...nextTarget.data, tags: flagTags.length > 0 ? flagTags : undefined },
+                    };
+                }
+                let nextPhase;
+                if (!hasTools) {
+                    // The loading-tools effect detects whether we're non-interactive and
+                    // either resolves tools from the manifest/flag/inference or errors out.
+                    nextPhase = 'loading-tools';
+                }
+                else {
+                    nextPhase = 'checking-registry';
+                }
+                return {
+                    ...state,
+                    phase: nextPhase,
+                    reviewerValue,
+                    target: nextTarget,
+                    validation: action.validation,
+                };
+            }
+            let nextPhase;
+            if (!hasTags) {
+                nextPhase = 'prompting-tags';
+            }
+            else if (!hasTools) {
+                nextPhase = 'loading-tools';
+            }
+            else {
+                nextPhase = isOrgScoped ? 'prompting-reviewer' : 'checking-registry';
+            }
+            return {
+                ...state,
+                phase: nextPhase,
+                reviewerValue,
+                validation: action.validation,
+            };
+        }
+        default:
+            return state;
+    }
+}
+/**
+ * The step before `building-plan`, once the root asset's own checks are done:
+ * check the entries not yet checked, then settle each entry that needs a bump
+ * (the bump prompt; `--bump` or an error when non-interactive), then plan.
+ */
+function advanceToPlan(state) {
+    if (state.entries.some((entry) => !entry.versionCheck)) {
+        return { ...state, bumpEntry: undefined, phase: 'checking-entries' };
+    }
+    // A batch without --bump names every asset that needs one, not just the first.
+    if (isBatch(state.flags) && state.nonInteractive && !state.flags.bump) {
+        const pending = [
+            ...(state.target && state.versionCheck?.status === 'needs-bump' && !state.resolvedVersion
+                ? [{ label: state.flags.rawPath, latestVersion: state.versionCheck.latestVersion, target: state.target }]
+                : []),
+            ...state.entries.flatMap((entry) => entry.versionCheck?.status === 'needs-bump' && entry.resolvedVersion === undefined
+                ? [{ label: entry.label, latestVersion: entry.versionCheck.latestVersion, target: entry.target }]
+                : []),
+        ];
+        if (pending.length > 0) {
+            const lines = pending.map((p) => `  ${p.label}: ${p.target.assetType}:${p.target.data.name} v${p.target.data.version}, registry has v${p.latestVersion}`);
+            return {
+                ...state,
+                errorMessage: `--bump <patch|minor|major> required: these manifests are not newer than the registry:\n${lines.join('\n')}`,
+                phase: 'error',
+            };
+        }
+    }
+    const index = state.entries.findIndex((entry) => entry.versionCheck?.status === 'needs-bump' && entry.resolvedVersion === undefined);
+    const entry = state.entries[index];
+    if (entry?.versionCheck?.status !== 'needs-bump') {
+        return { ...state, bumpEntry: undefined, phase: 'building-plan' };
+    }
+    if (!state.nonInteractive) {
+        return { ...state, bumpEntry: index, bumpSelection: '', phase: 'bump-prompt' };
+    }
+    const { latestVersion } = entry.versionCheck;
+    if (!state.flags.bump) {
+        return {
+            ...state,
+            errorMessage: `--bump <patch|minor|major> required: registry has v${latestVersion} of ${entry.target.assetType}:${entry.target.data.name} (from ${entry.label}) but its manifest is not newer`,
+            phase: 'error',
+        };
+    }
+    return bumpEntryAt(state, index, state.flags.bump);
+}
+/**
+ * Bump the entry at `index` from its registry version, then go on toward the
+ * plan; an error state, as for the root, when the version can't be bumped.
+ */
+function bumpEntryAt(state, index, bump) {
+    const entry = state.entries[index];
+    if (entry?.versionCheck?.status !== 'needs-bump')
+        return state;
+    let version;
+    try {
+        version = bumpVersion(entry.versionCheck.latestVersion, bump);
+    }
+    catch {
+        return { ...state, errorMessage: `Failed to compute bumped version for ${entry.label}.`, phase: 'error' };
+    }
+    return advanceToPlan({ ...state, entries: replaceEntry(state.entries, index, withVersion(entry, version)) });
+}
+/**
+ * Phase to enter once the tags/tools metadata prompts are resolved: org-scoped
+ * targets get the reviewer prompt, everything else proceeds to the registry check.
+ */
+function phaseAfterMetadata(target) {
+    return target && isOrgScopedTarget(target) ? 'prompting-reviewer' : 'checking-registry';
+}
+function replaceEntry(entries, index, entry) {
+    return entries.map((current, i) => (i === index ? entry : current));
+}
+/** The entry published at `version`; a successful publish writes it to the entry's manifest. */
+function withVersion(entry, version) {
+    return {
+        ...entry,
+        resolvedVersion: version,
+        target: { ...entry.target, data: { ...entry.target.data, version } },
+    };
+}
 //# sourceMappingURL=publish-flow.js.map