@detergent-software/atk 8.9.0-dev.2 → 8.9.0-dev.21

package/build/lib/publish-flow.js

@@ -0,0 +1,1242 @@
+import { writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { compare as semverCompare, valid as semverValid } from 'semver';
+import { loadAllAdapters } from './adapter.js';
+import { isApiError } from './api-client.js';
+import { getCredential } from './auth.js';
+import { errorGuidance, errorMessage } from './errors.js';
+import { detectCompatibleTools, getSignedInUserName } from './init.js';
+import { findInstalledAsset, readLockfile } from './lockfile.js';
+import { diffManifests, fetchExistingManifest } from './manifest-diff.js';
+import { parseOrgFromName } from './org.js';
+import { findProjectRoot } from './paths.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, fetchAssetFileBytes, fetchAssetReadme, fetchRegistry, findAsset } from './registry.js';
+import { parseReviewersInput, validateGithubUsername } from './reviewers.js';
+import { stageInstalledFiles } from './staging.js';
+import { resolveTools } from './tool-resolver.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export function createInitialState(flags) {
+    // Non-interactive when --yes, --dry-run, --json, or stdin is not a TTY (raw mode
+    // unsupported). Defaults isTTY to true when the flag is omitted (call site responsible
+    // for threading useStdin().isRawModeSupported in). --dry-run and --json force
+    // non-interactive regardless of TTY — JSON output cannot interleave with prompts.
+    const isTTY = flags.isTTY ?? true;
+    const nonInteractive = Boolean(flags.yes) || flags.dryRun || Boolean(flags.json) || !isTTY;
+    const flagError = batchFlagError(flags);
+    return {
+        authorValue: '',
+        bumpSelection: '',
+        confirmValue: '',
+        descriptionValue: '',
+        entries: [],
+        errorMessage: flagError ?? '',
+        flags,
+        isRawPublish: false,
+        isUpdate: false,
+        manifestDiff: undefined,
+        metadataSubPhase: 'description',
+        missingDependencies: [],
+        nonInteractive,
+        orgValue: '',
+        phase: flagError
+            ? 'error'
+            : flags.update
+                ? 'resolving-update'
+                : flags.fromInstalled
+                    ? 'resolving-installed'
+                    : 'detecting',
+        plan: undefined,
+        progressMessage: '',
+        promptTagsValue: '',
+        publishConfirmValue: '',
+        publishResult: undefined,
+        rawDetection: null,
+        resolvedPath: flags.update ? '' : flags.fromInstalled ? '' : resolve(flags.rawPath),
+        resolvedVersion: '',
+        reviewerValue: '',
+        selectedPromptTools: [],
+        suggestedEntries: [],
+        tagsValue: '',
+        target: undefined,
+        token: undefined,
+        toolAdapters: [],
+        toolsDetected: [],
+        validation: undefined,
+        versionCheck: undefined,
+        withConfirmValue: '',
+    };
+}
+/** Several folders published together (`atk publish a b c`) in one pull request; one folder named twice is one. */
+export function isBatch(flags) {
+    return new Set(flags.paths?.map((path) => resolve(path))).size > 1;
+}
+/**
+ * Run the step for the state's phase, if it has one: the work the phase waits on,
+ * reported through `ctx.dispatch`, which reaches the runner only until the run is
+ * cancelled. An error the step throws is dispatched too, so this never rejects.
+ * Prompt and terminal phases have no step.
+ */
+export async function runPublishStep(state, ctx) {
+    const step = stepFor(state);
+    if (!step)
+        return;
+    const guarded = {
+        ...ctx,
+        dispatch: (action) => {
+            if (!ctx.cancelled())
+                ctx.dispatch(action);
+        },
+    };
+    try {
+        await step.run(state, guarded);
+    }
+    catch (err) {
+        if (ctx.cancelled())
+            return;
+        const action = step.fail
+            ? await step.fail(err, state, guarded).catch(() => toErrorAction(err))
+            : toErrorAction(err);
+        if (action)
+            guarded.dispatch(action);
+    }
+}
+/** The comma-separated values in a flag or prompt answer, trimmed, without empty ones. */
+export function splitList(value) {
+    return (value ?? '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+/** Why the flags can't publish a batch: one installed asset, or one asset's metadata. Undefined otherwise. */
+function batchFlagError(flags) {
+    if (!isBatch(flags))
+        return undefined;
+    if (flags.update || flags.fromInstalled) {
+        return `${flags.update ? '--update' : '--from-installed'} publishes one installed asset; leave it out to publish several folders.`;
+    }
+    const perAsset = [
+        ['--description', flags.descriptionFlag],
+        ['--tags', flags.tagsFlag],
+        ['--tools', flags.toolsFlag],
+    ].flatMap(([flag, value]) => (value === undefined ? [] : [flag]));
+    if (perAsset.length > 0) {
+        return `${perAsset.join(', ')} ${perAsset.length === 1 ? 'sets' : 'set'} one asset's metadata; put it in each folder's manifest.json to publish several folders.`;
+    }
+    return undefined;
+}
+/** In a batch, what the API calls `Root asset`, as the folder the user named. */
+function batchRootLabel(state) {
+    return isBatch(state.flags) ? state.flags.rawPath : undefined;
+}
+/** What the API calls `dependencies[i]`, as the folder the user named. */
+function entryLabels(state) {
+    return state.entries.map((entry) => entry.label);
+}
+/** The installed asset `--from-installed` or `--update` names, with the tool's adapter; an error when it isn't installed. */
+async function findInstalledSource(state, ctx) {
+    const assetName = state.flags.rawPath;
+    const { name, org } = parseOrgFromName(assetName);
+    const projectRoot = findProjectRoot(state.flags.projectRoot);
+    const tools = await resolveTools(state.flags.tool);
+    const adapter = tools[0].adapter;
+    const lockfile = await readLockfile(projectRoot);
+    const installed = findInstalledAsset(lockfile, name, undefined, org);
+    if (!installed) {
+        ctx.dispatch({ message: `Asset '${assetName}' is not installed.`, type: 'ERROR' });
+        return undefined;
+    }
+    return { adapter, installed, org, projectRoot };
+}
+/** Run the writes in order until one throws: its index and error, or undefined when all succeed. */
+async function firstFailure(edits) {
+    for (const [index, edit] of edits.entries()) {
+        try {
+            await edit.write();
+        }
+        catch (error) {
+            return { error, index };
+        }
+    }
+    return undefined;
+}
+function stepFor(state) {
+    switch (state.phase) {
+        case 'building-plan':
+            return buildingPlan;
+        case 'checking-entries':
+            return checkingEntries;
+        case 'checking-registry':
+            return checkingRegistry;
+        case 'detecting':
+            return detecting;
+        case 'gathering-metadata':
+            return state.metadataSubPhase === 'building-staging' ? buildingStaging : undefined;
+        case 'loading-tools':
+            return loadingTools;
+        case 'publishing':
+            return publishing;
+        case 'resolving-installed':
+            return resolvingInstalled;
+        case 'resolving-update':
+            return resolvingUpdate;
+        case 'validating':
+            return validating;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Folders next to the root asset that could fix the plan's error: an interactive
+ * run, a `422` naming root dependencies that aren't in the registry (or have no
+ * matching version), and a sibling folder whose manifest has the same type and
+ * name that isn't an entry yet. Undefined when there is nothing to offer.
+ * `--update` and `--from-installed` roots live in a temp folder, so they never get offers.
+ */
+async function suggestSiblingEntries(state, err) {
+    const { target } = state;
+    if (state.nonInteractive ||
+        state.flags.fromInstalled ||
+        state.flags.update ||
+        target?.type !== 'asset' ||
+        !(isApiError(err, 'dependency_not_found') || isApiError(err, 'dependency_version_unsatisfied'))) {
+        return undefined;
+    }
+    const included = (d) => state.entries.some((e) => e.target.assetType === d.type && e.target.data.name === d.name);
+    const missing = missingDependencies(target.data, err.issues).filter((d) => !included(d));
+    if (missing.length === 0)
+        return undefined;
+    const rootDir = state.rawDetection?.sourceDir ?? target.sourceDir;
+    const suggested = await findSiblingDependencies(rootDir, missing, state.entries.map((e) => e.target.sourceDir), target.data.org);
+    return suggested.length > 0 ? { missing, suggested } : undefined;
+}
+/**
+ * Build an ERROR dispatch action from a caught value, carrying the `code`,
+ * `hint` and `command` typed errors have so commands can render actionable
+ * recovery guidance.
+ */
+function toErrorAction(err, override) {
+    return {
+        ...errorGuidance(err),
+        message: override ?? errorMessage(err),
+        type: 'ERROR',
+    };
+}
+/**
+ * Write what the run changed in memory to the manifests on disk: the root's bump and each
+ * entry's, and the tags and tools the prompts asked for. Only once the publish has opened its
+ * PR, so a cancelled or failed one leaves every manifest as it was. A file whose write fails
+ * takes none of its later edits and comes back as one warning naming the fields it lacks; the
+ * other files are still written.
+ */
+async function writeManifestEdits(state) {
+    const target = state.target;
+    if (!target)
+        return [];
+    const files = new Map();
+    const edit = (dir, file, field, value, write) => {
+        const path = join(dir, file);
+        files.set(path, [...(files.get(path) ?? []), { field, value, write }]);
+    };
+    const version = (dir, file, value) => edit(dir, file, 'version', value, () => updateManifestVersion(dir, file, value));
+    const field = (name, value) => edit(target.sourceDir, 'manifest.json', name, value, () => updateManifestField(target.sourceDir, 'manifest.json', name, value));
+    if (state.versionCheck?.status === 'needs-bump' && state.resolvedVersion) {
+        version(target.sourceDir, target.type === 'asset' ? 'manifest.json' : 'bundle.json', state.resolvedVersion);
+    }
+    // Only an asset's manifest.json takes the prompted tags and tools, as the target (and so the plan) has them.
+    if (target.type === 'asset') {
+        const { tags, tools } = target.data;
+        if (state.promptTagsValue && tags && tags.length > 0) {
+            field('tags', tags);
+        }
+        if (state.selectedPromptTools.length > 0) {
+            field('tools', tools);
+        }
+    }
+    for (const entry of state.entries) {
+        if (entry.versionCheck?.status === 'needs-bump' && entry.resolvedVersion) {
+            version(entry.target.sourceDir, 'manifest.json', entry.resolvedVersion);
+        }
+    }
+    const unwritten = [];
+    for (const [path, edits] of files) {
+        const failed = await firstFailure(edits);
+        if (!failed)
+            continue;
+        const missing = edits.slice(failed.index);
+        // Only the version matters to the next publish: it asks for missing tags and tools again.
+        const again = missing.some((e) => e.field === 'version') ? ' before you publish it again' : '';
+        unwritten.push(`The PR is open, but ${path} wasn't updated (${errorMessage(failed.error)}): set ${missing.map((e) => `"${e.field}" to ${JSON.stringify(e.value)}`).join(', ')}${again}.`);
+    }
+    return unwritten;
+}
+// ---------------------------------------------------------------------------
+// Steps, one per phase that waits on work
+// ---------------------------------------------------------------------------
+const resolvingInstalled = {
+    async run(state, ctx) {
+        const source = await findInstalledSource(state, ctx);
+        if (!source)
+            return;
+        const { adapter, installed, projectRoot } = source;
+        // Copy the installed files into a temp directory, preserving their source paths
+        const tempDir = await stageInstalledFiles(installed, adapter, projectRoot);
+        ctx.stage(tempDir);
+        if (ctx.cancelled())
+            return;
+        // Generate manifest.json in the temp dir
+        const manifest = {
+            author: 'unknown',
+            description: `Published from installed asset ${installed.name}`,
+            entrypoint: installed.files[0]?.sourcePath ?? 'index.md',
+            name: installed.name,
+            ...(installed.org ? { org: installed.org } : {}),
+            type: installed.type,
+            version: installed.version,
+        };
+        await writeFile(join(tempDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+        ctx.dispatch({ resolvedPath: tempDir, type: 'RESOLVED_INSTALLED' });
+    },
+};
+const resolvingUpdate = {
+    async run(state, ctx) {
+        const source = await findInstalledSource(state, ctx);
+        if (!source)
+            return;
+        const { adapter, installed, org, projectRoot } = source;
+        const assetName = state.flags.rawPath;
+        // Fetch the registry to find the latest version. An installed entry is always an asset.
+        const registry = await fetchRegistry({ force: state.flags.refresh });
+        if (ctx.cancelled())
+            return;
+        const resolvedAsset = findAsset(registry, installed.name, installed.type, undefined, installed.org ?? org);
+        if (!resolvedAsset) {
+            ctx.dispatch({ message: `Asset '${assetName}' not found in the registry.`, type: 'ERROR' });
+            return;
+        }
+        // The installed files go out on top of the latest's manifest, so they must not be older
+        // than it: they would publish the next version without the changes made since.
+        const latestVersion = resolvedAsset.version;
+        if (!semverValid(installed.version) || semverCompare(installed.version, latestVersion) < 0) {
+            ctx.dispatch({
+                command: `atk diff ${assetName}`,
+                hint: `See what changed since v${installed.version} with \`atk diff ${assetName}\`, get the latest into a folder with \`atk checkout ${assetName}\`, carry your edits into it, and publish that folder.`,
+                message: `'${assetName}' is installed at v${installed.version}, but the registry's latest is v${latestVersion}. --update would publish your copy, built on v${installed.version}, as the next version and undo the changes made since.`,
+                type: 'ERROR',
+            });
+            return;
+        }
+        // The latest's manifest as the registry has it, byte for byte, so a field this CLI's schema
+        // doesn't know (from a newer publisher) is published again; and its README, if any.
+        const { org: assetOrg, type } = resolvedAsset.asset;
+        const ref = { name: installed.name, ...(assetOrg ? { org: assetOrg } : {}), type };
+        const [manifest, readme] = await Promise.all([
+            fetchAssetFileBytes(ref, latestVersion, 'manifest.json'),
+            fetchAssetReadme(ref, latestVersion),
+        ]);
+        if (ctx.cancelled())
+            return;
+        // Copy the user's locally modified files into a temp staging directory
+        const tempDir = await stageInstalledFiles(installed, adapter, projectRoot);
+        ctx.stage(tempDir);
+        if (ctx.cancelled())
+            return;
+        await writeFile(join(tempDir, 'manifest.json'), manifest);
+        if (readme) {
+            await writeFile(join(tempDir, 'README.md'), readme, 'utf-8');
+        }
+        ctx.dispatch({ resolvedPath: tempDir, type: 'RESOLVED_UPDATE' });
+    },
+};
+const detecting = {
+    async run(state, ctx) {
+        // A batch reads every folder now; any that is missing, a bundle or not an asset folder
+        // fails here, all of them together, before any prompt.
+        if (isBatch(state.flags)) {
+            const { entries, root } = await loadPublishBatch(state.flags.paths ?? [], state.flags.withPaths);
+            if (ctx.cancelled())
+                return;
+            ctx.dispatch({ entries, type: 'ENTRIES_LOADED' });
+            ctx.dispatch({ target: root.target, type: 'DETECT_DONE' });
+            return;
+        }
+        // A --with folder that is missing, a bundle, the root or a repeat fails here, before any
+        // prompt; its validation and version check come in checking-entries.
+        if (state.flags.withPaths?.length) {
+            const entries = await loadPublishEntries(state.flags.withPaths, state.resolvedPath);
+            if (ctx.cancelled())
+                return;
+            ctx.dispatch({ entries, type: 'ENTRIES_LOADED' });
+        }
+        // First, try manifest-based detection (existing flow)
+        try {
+            const detected = await detectPublishType(state.resolvedPath);
+            if (ctx.cancelled())
+                return;
+            ctx.dispatch({ target: detected, type: 'DETECT_DONE' });
+            return;
+        }
+        catch (manifestError) {
+            // Only attempt raw detection if the error is specifically about missing manifest/bundle
+            const manifestMsg = errorMessage(manifestError);
+            if (!manifestMsg.includes('No manifest.json or bundle.json found')) {
+                // This is a different error (e.g., invalid JSON in manifest) — surface it directly
+                ctx.dispatch({ message: manifestMsg, type: 'ERROR' });
+                return;
+            }
+        }
+        // Manifest not found — attempt raw asset detection
+        const resolvedTools = await resolveTools(state.flags.tool);
+        const adapter = resolvedTools[0].adapter;
+        if (ctx.cancelled())
+            return;
+        const projectRoot = findProjectRoot(state.flags.projectRoot);
+        const detection = await detectAssetFromPath(state.resolvedPath, adapter, projectRoot);
+        if (ctx.cancelled())
+            return;
+        // Pre-fill metadata
+        const author = (await getSignedInUserName()) ?? '';
+        if (ctx.cancelled())
+            return;
+        const lockfile = await readLockfile(projectRoot);
+        if (ctx.cancelled())
+            return;
+        const tools = await detectCompatibleTools(detection.assetType);
+        if (ctx.cancelled())
+            return;
+        // Non-interactive mode (raw publish — no manifest exists yet, so the only
+        // sources for description are --description flag or exit-1; tags come from
+        // --tags or default to empty). Tool detection runs for both modes above.
+        if (!state.nonInteractive) {
+            // Interactive mode — gather metadata from the user
+            ctx.dispatch({
+                authorValue: author,
+                orgValue: lockfile.org ?? '',
+                rawDetection: detection,
+                toolsDetected: tools,
+                type: 'RAW_DETECT_DONE',
+            });
+            return;
+        }
+        if (!state.flags.descriptionFlag) {
+            ctx.dispatch({
+                message: 'description required: provide --description or include in manifest.json',
+                type: 'ERROR',
+            });
+            return;
+        }
+        // Tools resolution: --tools flag -> detected (already populated above)
+        let toolsList;
+        if (state.flags.toolsFlag) {
+            toolsList = splitList(state.flags.toolsFlag);
+        }
+        else if (tools.length > 0) {
+            toolsList = tools;
+        }
+        else {
+            ctx.dispatch({
+                message: `--tools <comma-separated> required: no tools detected for type ${detection.assetType}`,
+                type: 'ERROR',
+            });
+            return;
+        }
+        const stagingDir = await buildStagingArea(detection, {
+            author,
+            description: state.flags.descriptionFlag,
+            ...(lockfile.org ? { org: lockfile.org } : {}),
+            tags: splitList(state.flags.tagsFlag),
+            tools: toolsList,
+        });
+        ctx.stage(stagingDir);
+        if (ctx.cancelled())
+            return;
+        const detected = await detectPublishType(stagingDir);
+        if (ctx.cancelled())
+            return;
+        ctx.dispatch({ rawDetection: detection, target: detected, type: 'RAW_DETECT_DONE_NON_INTERACTIVE' });
+    },
+};
+/** The `building-staging` sub-phase of `gathering-metadata`: the manifest from the prompts' answers. */
+const buildingStaging = {
+    async run(state, ctx) {
+        const stagingDir = await buildStagingArea(state.rawDetection, {
+            author: state.authorValue,
+            description: state.descriptionValue,
+            org: state.orgValue || undefined,
+            tags: splitList(state.tagsValue),
+            tools: state.toolsDetected,
+        });
+        ctx.stage(stagingDir);
+        if (ctx.cancelled())
+            return;
+        // Re-detect using the staging area (now has manifest.json)
+        const detectedTarget = await detectPublishType(stagingDir);
+        if (ctx.cancelled())
+            return;
+        ctx.dispatch({ target: detectedTarget, type: 'STAGING_DONE' });
+    },
+};
+const validating = {
+    async run(state, ctx) {
+        const target = state.target;
+        if (!target)
+            return;
+        let lockfileOrg;
+        let lockfileOrgReviewers;
+        try {
+            const projectRoot = findProjectRoot(state.flags.projectRoot);
+            const lockfile = await readLockfile(projectRoot);
+            lockfileOrg = lockfile.org;
+            lockfileOrgReviewers = lockfile.orgReviewers;
+        }
+        catch {
+            // No project root / lockfile — treat as no lockfile org / reviewers
+        }
+        if (ctx.cancelled())
+            return;
+        // Bundles need the registry so their asset refs can be resolved during
+        // validation — an unresolvable ref must fail here, not at install time.
+        let registry;
+        if (target.type === 'bundle') {
+            registry = await fetchRegistry({ force: state.flags.refresh });
+            if (ctx.cancelled())
+                return;
+        }
+        const result = await validatePublishTarget(target, {
+            force: state.flags.force,
+            lockfileOrg,
+            registry,
+        });
+        if (ctx.cancelled())
+            return;
+        // A batch checks every asset before stopping, so one run lists every folder's problems.
+        if (isBatch(state.flags)) {
+            const entries = [];
+            for (const entry of state.entries) {
+                const validation = await validatePublishTarget(entry.target, { force: state.flags.force, lockfileOrg });
+                if (ctx.cancelled())
+                    return;
+                entries.push({ ...entry, validation });
+            }
+            const failed = [{ label: state.flags.rawPath, validation: result }, ...entries].filter((f) => f.validation && !f.validation.valid);
+            if (failed.length > 0) {
+                const lines = failed.flatMap((f) => [
+                    `  ${f.label}:`,
+                    ...(f.validation?.errors ?? []).map((e) => `    - ${e}`),
+                ]);
+                ctx.dispatch({ message: `Validation failed:\n${lines.join('\n')}`, type: 'ERROR' });
+                return;
+            }
+            // checking-entries keeps these instead of validating each entry again.
+            ctx.dispatch({ entries, type: 'ENTRIES_LOADED' });
+        }
+        ctx.dispatch({ lockfileOrgReviewers, type: 'VALIDATE_DONE', validation: result });
+    },
+};
+/**
+ * In interactive mode, loads adapters for the multi-select prompt. In non-interactive
+ * mode, resolves tools via manifest -> --tools flag -> detectCompatibleTools(assetType)
+ * -> exit 1, then dispatches RESOLVE_TOOLS_NONINTERACTIVE to advance directly to
+ * checking-registry.
+ */
+const loadingTools = {
+    async run(state, ctx) {
+        if (!state.nonInteractive) {
+            const adapters = await loadAllAdapters();
+            if (ctx.cancelled())
+                return;
+            ctx.dispatch({ adapters, type: 'TOOLS_LOADED' });
+            return;
+        }
+        // Manifest tools win when present (VALIDATE_DONE only routes here when
+        // manifest tools are missing for assets — bundles short-circuit hasTools).
+        if (state.target?.type !== 'asset') {
+            // Bundles don't carry tools — just advance.
+            ctx.dispatch({ tools: [], type: 'RESOLVE_TOOLS_NONINTERACTIVE' });
+            return;
+        }
+        // Try --tools flag
+        let resolvedToolList = splitList(state.flags.toolsFlag);
+        if (state.flags.toolsFlag) {
+            // Validation ran before these tools were filled in, so check them here.
+            const toolsError = await unknownToolsError(resolvedToolList);
+            if (ctx.cancelled())
+                return;
+            if (toolsError) {
+                ctx.dispatch({ message: `--tools: ${toolsError}`, type: 'ERROR' });
+                return;
+            }
+        }
+        // Fall back to detectCompatibleTools
+        if (resolvedToolList.length === 0) {
+            const assetType = state.target.assetType;
+            if (!assetType) {
+                ctx.dispatch({
+                    message: '--tools <comma-separated> required: no tools detected for type unknown',
+                    type: 'ERROR',
+                });
+                return;
+            }
+            const detected = await detectCompatibleTools(assetType);
+            if (ctx.cancelled())
+                return;
+            if (detected.length === 0) {
+                ctx.dispatch({
+                    message: `--tools <comma-separated> required: no tools detected for type ${assetType}`,
+                    type: 'ERROR',
+                });
+                return;
+            }
+            resolvedToolList = detected;
+        }
+        ctx.dispatch({ tools: resolvedToolList, type: 'RESOLVE_TOOLS_NONINTERACTIVE' });
+    },
+};
+const checkingRegistry = {
+    async fail(err) {
+        return toErrorAction(err, mapPublishError(err));
+    },
+    async run(state, ctx) {
+        const target = state.target;
+        if (!target)
+            return;
+        const authToken = (await getCredential()).token;
+        if (ctx.cancelled())
+            return;
+        const reg = await fetchRegistry({ force: state.flags.refresh });
+        if (ctx.cancelled())
+            return;
+        const versionResult = checkRegistryVersion(target, reg);
+        // A version the registry doesn't have yet is published as it is; needs-bump settles it later.
+        const isUpdate = versionResult.status !== 'new-asset';
+        const resolvedVersion = versionResult.status === 'needs-bump' ? '' : target.data.version;
+        ctx.dispatch({
+            isUpdate,
+            resolvedVersion,
+            token: authToken,
+            type: 'REGISTRY_CHECK_DONE',
+            versionCheck: versionResult,
+        });
+    },
+};
+/**
+ * Validate each entry not yet checked the same way as the root asset, and check its
+ * version against the registry; advanceToPlan then settles any bump it needs.
+ */
+const checkingEntries = {
+    async fail(err) {
+        return toErrorAction(err, mapPublishError(err));
+    },
+    async run(state, ctx) {
+        let lockfileOrg;
+        try {
+            lockfileOrg = (await readLockfile(findProjectRoot(state.flags.projectRoot))).org;
+        }
+        catch {
+            // No project root / lockfile — treat as no lockfile org
+        }
+        const registry = await fetchRegistry({ force: state.flags.refresh });
+        if (ctx.cancelled())
+            return;
+        const entries = [];
+        for (const entry of state.entries) {
+            if (entry.versionCheck) {
+                entries.push(entry);
+                continue;
+            }
+            const validation = entry.validation ?? (await validatePublishTarget(entry.target, { force: state.flags.force, lockfileOrg }));
+            if (ctx.cancelled())
+                return;
+            if (!validation.valid) {
+                ctx.dispatch({
+                    message: `Validation failed for ${entry.label}:\n${validation.errors.map((e) => `  - ${e}`).join('\n')}`,
+                    type: 'ERROR',
+                });
+                return;
+            }
+            const versionCheck = checkRegistryVersion(entry.target, registry);
+            entries.push({
+                ...entry,
+                ...(versionCheck.status === 'needs-bump' ? {} : { resolvedVersion: entry.target.data.version }),
+                validation,
+                versionCheck,
+            });
+        }
+        ctx.dispatch({ entries, type: 'ENTRIES_CHECKED' });
+    },
+};
+/**
+ * Plans from the targets in memory, which carry every bump and prompted tag or tool:
+ * nothing is written to a manifest until the publish succeeds (writeManifestEdits).
+ */
+const buildingPlan = {
+    async fail(err, state, ctx) {
+        // Worded like the publishing phase: resolvePlanDependencies calls the same API.
+        const error = toErrorAction(err, mapPublishError(err, entryLabels(state), batchRootLabel(state)));
+        const suggestion = await suggestSiblingEntries(state, err).catch(() => undefined);
+        if (ctx.cancelled())
+            return undefined;
+        return suggestion ? { error, ...suggestion, type: 'SUGGEST_ENTRIES' } : error;
+    },
+    async run(state, ctx) {
+        const currentTarget = state.target;
+        if (!currentTarget)
+            return;
+        const currentVersion = state.resolvedVersion;
+        // Reject invalid reviewer usernames here, before any branch/commit/push work happens
+        const reviewers = parseReviewersInput(state.reviewerValue);
+        for (const reviewer of reviewers) {
+            const check = validateGithubUsername(reviewer);
+            if (!check.valid) {
+                throw new Error(check.error);
+            }
+        }
+        const entries = state.entries.map((entry) => ({ label: entry.label, target: entry.target }));
+        const localPlan = await buildPublishPlan(currentTarget, currentVersion, state.isUpdate, state.flags.message, reviewers, entries, ...(isBatch(state.flags) ? [state.flags.rawPath] : []));
+        if (ctx.cancelled())
+            return;
+        // Ask the API for its plan now, so the preview and --dry-run show its dependencies
+        // and reviewers, and anything it rejects stops before the confirm prompt.
+        const publishPlan = await resolvePlanDependencies(localPlan);
+        if (ctx.cancelled())
+            return;
+        let manifestDiff;
+        if (state.isUpdate && state.versionCheck && state.versionCheck.status !== 'new-asset' && state.token) {
+            const existing = await fetchExistingManifest(currentTarget, state.versionCheck.latestVersion);
+            if (ctx.cancelled())
+                return;
+            if (existing) {
+                manifestDiff = diffManifests(existing, currentTarget.data);
+            }
+        }
+        ctx.dispatch({ manifestDiff, plan: publishPlan, type: 'PLAN_DONE' });
+    },
+};
+const publishing = {
+    async fail(err, state) {
+        return toErrorAction(err, mapPublishError(err, entryLabels(state), batchRootLabel(state)));
+    },
+    async run(state, ctx) {
+        const plan = state.plan;
+        if (!plan || !state.token)
+            return;
+        const published = await executePublish(plan, (message) => ctx.dispatch({ message, type: 'PUBLISH_PROGRESS' }));
+        // The PR is open, so the folders take its versions, tags and tools even if the run was cancelled meanwhile.
+        const unwritten = await writeManifestEdits(state);
+        if (ctx.cancelled())
+            return;
+        const result = unwritten.length > 0 ? { ...published, warnings: [...(published.warnings ?? []), ...unwritten] } : published;
+        // Clear registry cache so subsequent commands see the new version
+        try {
+            await clearCache();
+        }
+        catch {
+            // Best-effort — don't fail publish over cache
+        }
+        // The lockfile is left as it was, even for an installed asset or a raw folder: the registry
+        // has the new version only once the PR merges, and a fresh clone installs the version the
+        // lockfile names (ATK-592). `atk update` (or `atk install`) records it after the merge.
+        if (ctx.cancelled())
+            return;
+        ctx.dispatch({ result, type: 'PUBLISH_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 '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':
+            return { ...state, phase: 'done', 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