@detergent-software/atk 3.0.0 → 5.0.0-dev.1

package/build/hooks/usePublishState.js

@@ -0,0 +1,916 @@
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { useEffect, useReducer, useRef } from 'react';
+import { loadAllAdapters, resolveInstalledPaths } from '../lib/adapter.js';
+import { getGitHubToken } from '../lib/auth.js';
+import { hashFile } from '../lib/checksum.js';
+import { fetchAssetFiles } from '../lib/github.js';
+import { detectCompatibleTools, getGitUserName } from '../lib/init.js';
+import { addAssetToLockfile, findInstalledAsset, readLockfile, withLockfileLock, writeLockfile, } from '../lib/lockfile.js';
+import { parseOrgFromName } from '../lib/org.js';
+import { findProjectRoot } from '../lib/paths.js';
+import { buildPublishPlan, buildStagingArea, bumpVersion, checkRegistryVersion, detectAssetFromPath, detectPublishType, executePublish, mapPublishError, updateManifestField, updateManifestVersion, validatePublishTarget, } from '../lib/publisher.js';
+import { clearCache, fetchRegistry, findAsset, findBundle } from '../lib/registry.js';
+import { resolveTools } from '../lib/tool-resolver.js';
+// ---------------------------------------------------------------------------
+// Initial state factory
+// ---------------------------------------------------------------------------
+export function createInitialState(flags) {
+    return {
+        authorValue: '',
+        bumpSelection: '',
+        confirmValue: '',
+        descriptionValue: '',
+        errorMessage: '',
+        flags,
+        isRawPublish: false,
+        isUpdate: false,
+        metadataSubPhase: 'description',
+        orgValue: '',
+        phase: 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: '',
+        selectedPromptTools: [],
+        tagsValue: '',
+        target: undefined,
+        token: undefined,
+        toolAdapters: [],
+        toolCursorIndex: 0,
+        toolsDetected: [],
+        validation: undefined,
+        versionCheck: undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Pure reducer
+// ---------------------------------------------------------------------------
+export function publishReducer(state, action) {
+    switch (action.type) {
+        case 'BUMP_DONE':
+            return {
+                ...state,
+                errorMessage: action.message ? action.message : state.errorMessage,
+                phase: action.message ? 'error' : 'building-plan',
+                resolvedVersion: action.version,
+                target: action.updatedTarget,
+            };
+        case 'CONFIRM_PROMPT_TOOLS': {
+            if (state.selectedPromptTools.length === 0)
+                return state;
+            const parsedTools = state.selectedPromptTools.map((tool) => ({ tool }));
+            const updatedToolsTarget = state.target
+                ? {
+                    ...state.target,
+                    data: { ...state.target.data, tools: parsedTools },
+                }
+                : undefined;
+            return {
+                ...state,
+                phase: 'checking-registry',
+                target: updatedToolsTarget,
+            };
+        }
+        case 'DETECT_DONE':
+            return {
+                ...state,
+                phase: 'validating',
+                target: action.target,
+            };
+        case 'ERROR':
+            return { ...state, errorMessage: action.message, phase: 'error' };
+        case 'INSTALL_DONE':
+            return { ...state, phase: 'done' };
+        case 'PLAN_DONE': {
+            const nextPhase = state.flags.dryRun ? 'dry-run-result' : 'confirm-publish';
+            return {
+                ...state,
+                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;
+            if (versionCheck.status === 'new-asset') {
+                nextPhase = 'building-plan';
+            }
+            else if (versionCheck.status === 'version-already-bumped') {
+                nextPhase = 'confirm-update';
+            }
+            else {
+                // needs-bump
+                nextPhase = 'bump-prompt';
+            }
+            return {
+                ...state,
+                isUpdate,
+                phase: nextPhase,
+                resolvedVersion,
+                token,
+                versionCheck,
+            };
+        }
+        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_TAGS':
+            return { ...state, tagsValue: action.value };
+        case 'STAGING_DONE':
+            return {
+                ...state,
+                phase: 'validating',
+                target: action.target,
+            };
+        case 'SUBMIT_BUMP': {
+            // Validation happens in the effect; reducer just acknowledges intent
+            // The effect will dispatch BUMP_DONE or ERROR
+            const trimmed = state.bumpSelection.trim().toLowerCase();
+            if (trimmed !== 'patch' && trimmed !== 'minor' && trimmed !== 'major') {
+                return state; // Ignore invalid input
+            }
+            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);
+                return {
+                    ...state,
+                    // Move to a transitional sub-state — the effect for bump-prompt
+                    // will see resolvedVersion is set and perform the async manifest update.
+                    // We keep phase as 'bump-prompt' so the effect can detect the submission.
+                    phase: 'building-plan',
+                    resolvedVersion: 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 { ...state, phase: 'building-plan' };
+            }
+            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': {
+            // Parse comma-separated tags from the prompt value
+            const parsedTags = state.promptTagsValue
+                .split(',')
+                .map((t) => t.trim())
+                .filter(Boolean);
+            // 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);
+            return {
+                ...state,
+                phase: needsToolsPrompt ? 'loading-tools' : 'checking-registry',
+                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_TAGS':
+            return {
+                ...state,
+                metadataSubPhase: 'building-staging',
+            };
+        case 'TOGGLE_PROMPT_TOOL': {
+            const toolSet = new Set(state.selectedPromptTools);
+            if (toolSet.has(action.tool)) {
+                toolSet.delete(action.tool);
+            }
+            else {
+                toolSet.add(action.tool);
+            }
+            return {
+                ...state,
+                selectedPromptTools: [...toolSet],
+            };
+        }
+        case 'TOOL_CURSOR_DOWN': {
+            if (state.toolAdapters.length === 0)
+                return state;
+            return {
+                ...state,
+                toolCursorIndex: state.toolCursorIndex >= state.toolAdapters.length - 1 ? 0 : state.toolCursorIndex + 1,
+            };
+        }
+        case 'TOOL_CURSOR_UP': {
+            if (state.toolAdapters.length === 0)
+                return state;
+            return {
+                ...state,
+                toolCursorIndex: state.toolCursorIndex <= 0 ? state.toolAdapters.length - 1 : state.toolCursorIndex - 1,
+            };
+        }
+        case 'TOOLS_LOADED':
+            return {
+                ...state,
+                phase: 'prompting-tools',
+                toolAdapters: action.adapters,
+                toolCursorIndex: 0,
+            };
+        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,
+                };
+            }
+            // Determine next phase based on missing tags/tools
+            const manifest = state.target?.data;
+            const hasTags = manifest && 'tags' in manifest && Array.isArray(manifest.tags) && manifest.tags.length > 0;
+            const hasTools = 
+            // 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);
+            let nextPhase;
+            if (!hasTags) {
+                nextPhase = 'prompting-tags';
+            }
+            else if (!hasTools) {
+                nextPhase = 'loading-tools';
+            }
+            else {
+                nextPhase = 'checking-registry';
+            }
+            return {
+                ...state,
+                phase: nextPhase,
+                validation: action.validation,
+            };
+        }
+        default:
+            return state;
+    }
+}
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+export function usePublishState(flags) {
+    const [state, dispatch] = useReducer(publishReducer, undefined, () => createInitialState(flags));
+    // Temp directory ref for staging / --from-installed cleanup
+    const tempDirRef = useRef(null);
+    // --- Phase: resolving-installed ---
+    useEffect(() => {
+        if (state.phase !== 'resolving-installed')
+            return;
+        let cancelled = false;
+        const resolveInstalled = async () => {
+            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) {
+                if (!cancelled) {
+                    dispatch({ message: `Asset '${assetName}' is not installed.`, type: 'ERROR' });
+                }
+                return;
+            }
+            // Create temp directory and copy installed files
+            const tempDir = await mkdir(join(tmpdir(), 'atk-publish-'), { recursive: true })
+                .then(() => join(tmpdir(), `atk-publish-${Date.now()}-${Math.random().toString(36).slice(2)}`))
+                .then(async (dir) => {
+                await mkdir(dir, { recursive: true });
+                return dir;
+            });
+            if (cancelled) {
+                await rm(tempDir, { force: true, recursive: true });
+                return;
+            }
+            tempDirRef.current = tempDir;
+            // Resolve installed paths via the adapter
+            const resolved = resolveInstalledPaths(installed, adapter, projectRoot);
+            // Copy each installed file preserving sourcePath directory structure
+            for (const file of resolved.files) {
+                const sourceAbsolute = join(projectRoot, file.installedPath);
+                const destPath = join(tempDir, file.sourcePath);
+                const destDir = dirname(destPath);
+                await mkdir(destDir, { recursive: true });
+                await cp(sourceAbsolute, destPath);
+            }
+            // 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');
+            if (!cancelled) {
+                dispatch({ resolvedPath: tempDir, type: 'RESOLVED_INSTALLED' });
+            }
+        };
+        resolveInstalled().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'resolving-installed'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: resolving-update ---
+    useEffect(() => {
+        if (state.phase !== 'resolving-update')
+            return;
+        let cancelled = false;
+        const resolveUpdate = async () => {
+            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) {
+                if (!cancelled) {
+                    dispatch({ message: `Asset '${assetName}' is not installed.`, type: 'ERROR' });
+                }
+                return;
+            }
+            // Get a GitHub token and fetch the registry to find the latest version
+            const token = await getGitHubToken();
+            if (cancelled)
+                return;
+            const registry = await fetchRegistry({ force: state.flags.refresh });
+            if (cancelled)
+                return;
+            // Look up the asset in the registry: try findAsset first, then findBundle
+            const resolvedAsset = findAsset(registry, installed.name, installed.type, undefined, installed.org ?? org);
+            const resolvedBundle = resolvedAsset ? undefined : findBundle(registry, installed.name);
+            if (!resolvedAsset && !resolvedBundle) {
+                if (!cancelled) {
+                    dispatch({ message: `Asset '${assetName}' not found in the registry.`, type: 'ERROR' });
+                }
+                return;
+            }
+            const latestVersion = resolvedAsset ? resolvedAsset.version : resolvedBundle.version;
+            const assetType = resolvedAsset ? resolvedAsset.asset.type : 'bundle';
+            // Fetch the authoritative manifest (and optional README) from the registry
+            const fetched = await fetchAssetFiles(token, { name: installed.name, org: installed.org ?? org, type: assetType }, latestVersion);
+            if (cancelled)
+                return;
+            // Create temp staging directory
+            const tempDir = await mkdir(join(tmpdir(), 'atk-publish-'), { recursive: true })
+                .then(() => join(tmpdir(), `atk-publish-${Date.now()}-${Math.random().toString(36).slice(2)}`))
+                .then(async (dir) => {
+                await mkdir(dir, { recursive: true });
+                return dir;
+            });
+            if (cancelled) {
+                await rm(tempDir, { force: true, recursive: true });
+                return;
+            }
+            tempDirRef.current = tempDir;
+            // Resolve installed paths and copy the user's locally modified files into staging
+            const resolved = resolveInstalledPaths(installed, adapter, projectRoot);
+            for (const file of resolved.files) {
+                const sourceAbsolute = join(projectRoot, file.installedPath);
+                const destPath = join(tempDir, file.sourcePath);
+                const destDir = dirname(destPath);
+                await mkdir(destDir, { recursive: true });
+                await cp(sourceAbsolute, destPath);
+            }
+            // Write the fetched manifest into the staging directory
+            await writeFile(join(tempDir, fetched.manifestFileName), fetched.manifestContent, 'utf-8');
+            // Write README if present
+            if (fetched.readmeContent) {
+                await writeFile(join(tempDir, 'README.md'), fetched.readmeContent, 'utf-8');
+            }
+            if (!cancelled) {
+                dispatch({ resolvedPath: tempDir, type: 'RESOLVED_UPDATE' });
+            }
+        };
+        resolveUpdate().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'resolving-update'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: detecting ---
+    useEffect(() => {
+        if (state.phase !== 'detecting')
+            return;
+        let cancelled = false;
+        const detect = async () => {
+            // First, try manifest-based detection (existing flow)
+            try {
+                const detected = await detectPublishType(state.resolvedPath);
+                if (cancelled)
+                    return;
+                dispatch({ target: detected, type: 'DETECT_DONE' });
+                return;
+            }
+            catch (manifestError) {
+                // Only attempt raw detection if the error is specifically about missing manifest/bundle
+                const manifestMsg = manifestError instanceof Error ? manifestError.message : String(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
+                    if (!cancelled) {
+                        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 (cancelled)
+                return;
+            const projectRoot = findProjectRoot(state.flags.projectRoot);
+            const detection = await detectAssetFromPath(state.resolvedPath, adapter, projectRoot);
+            if (cancelled)
+                return;
+            // Pre-fill metadata
+            const author = (await getGitUserName()) ?? '';
+            if (cancelled)
+                return;
+            const lockfile = await readLockfile(projectRoot);
+            if (cancelled)
+                return;
+            const tools = await detectCompatibleTools(detection.assetType);
+            if (cancelled)
+                return;
+            const orgVal = lockfile.org ?? '';
+            // Non-interactive mode: both --description and --tags flags provided
+            if (state.flags.descriptionFlag && state.flags.tagsFlag) {
+                const tags = state.flags.tagsFlag
+                    .split(',')
+                    .map((t) => t.trim())
+                    .filter(Boolean);
+                const stagingDir = await buildStagingArea(detection, {
+                    author,
+                    description: state.flags.descriptionFlag,
+                    ...(lockfile.org ? { org: lockfile.org } : {}),
+                    tags,
+                    tools: tools.map((t) => ({ tool: t })),
+                });
+                if (cancelled)
+                    return;
+                tempDirRef.current = stagingDir;
+                const detected = await detectPublishType(stagingDir);
+                if (cancelled)
+                    return;
+                dispatch({ rawDetection: detection, target: detected, type: 'RAW_DETECT_DONE_NON_INTERACTIVE' });
+            }
+            else {
+                // Interactive mode — gather metadata from the user
+                dispatch({
+                    authorValue: author,
+                    orgValue: orgVal,
+                    rawDetection: detection,
+                    toolsDetected: tools.map((t) => ({ tool: t })),
+                    type: 'RAW_DETECT_DONE',
+                });
+            }
+        };
+        detect().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'detecting'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: gathering-metadata / building-staging sub-phase ---
+    useEffect(() => {
+        if (state.phase !== 'gathering-metadata' || state.metadataSubPhase !== 'building-staging')
+            return;
+        let cancelled = false;
+        const build = async () => {
+            // Parse tags from comma-separated string
+            const tags = state.tagsValue
+                .split(',')
+                .map((t) => t.trim())
+                .filter(Boolean);
+            // Build staging area
+            const stagingDir = await buildStagingArea(state.rawDetection, {
+                author: state.authorValue,
+                description: state.descriptionValue,
+                org: state.orgValue || undefined,
+                tags,
+                tools: state.toolsDetected,
+            });
+            if (cancelled)
+                return;
+            // Store for cleanup
+            tempDirRef.current = stagingDir;
+            // Re-detect using the staging area (now has manifest.json)
+            const detectedTarget = await detectPublishType(stagingDir);
+            if (cancelled)
+                return;
+            dispatch({ target: detectedTarget, type: 'STAGING_DONE' });
+        };
+        build().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering building-staging sub-phase
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase, state.metadataSubPhase]);
+    // --- Phase: validating ---
+    useEffect(() => {
+        if (state.phase !== 'validating')
+            return;
+        if (!state.target)
+            return;
+        let cancelled = false;
+        const validate = async () => {
+            const result = await validatePublishTarget(state.target);
+            if (cancelled)
+                return;
+            dispatch({ type: 'VALIDATE_DONE', validation: result });
+        };
+        validate().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'validating'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: loading-tools ---
+    useEffect(() => {
+        if (state.phase !== 'loading-tools')
+            return;
+        let cancelled = false;
+        const load = async () => {
+            const adapters = await loadAllAdapters();
+            if (cancelled)
+                return;
+            dispatch({ adapters, type: 'TOOLS_LOADED' });
+        };
+        load().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'loading-tools'
+    }, [state.phase]);
+    // --- Phase: checking-registry ---
+    useEffect(() => {
+        if (state.phase !== 'checking-registry')
+            return;
+        if (!state.target)
+            return;
+        let cancelled = false;
+        const check = async () => {
+            const authToken = await getGitHubToken();
+            if (cancelled)
+                return;
+            const reg = await fetchRegistry({ force: state.flags.refresh });
+            if (cancelled)
+                return;
+            const versionResult = checkRegistryVersion(state.target, reg);
+            if (cancelled)
+                return;
+            let isUpdate = false;
+            let resolvedVersion = '';
+            if (versionResult.status === 'new-asset') {
+                isUpdate = false;
+                resolvedVersion = state.target.data.version;
+            }
+            else if (versionResult.status === 'version-already-bumped') {
+                isUpdate = true;
+                resolvedVersion = state.target.data.version;
+            }
+            else {
+                // needs-bump
+                isUpdate = true;
+            }
+            if (cancelled)
+                return;
+            dispatch({
+                isUpdate,
+                resolvedVersion,
+                token: authToken,
+                type: 'REGISTRY_CHECK_DONE',
+                versionCheck: versionResult,
+            });
+        };
+        check().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: mapPublishError(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'checking-registry'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: building-plan ---
+    // This effect also handles the async manifest update when coming from bump-prompt
+    useEffect(() => {
+        if (state.phase !== 'building-plan')
+            return;
+        if (!state.target)
+            return;
+        let cancelled = false;
+        const build = async () => {
+            let currentTarget = state.target;
+            const currentVersion = state.resolvedVersion;
+            // If we came from a bump submission, update the manifest file first
+            if (state.versionCheck?.status === 'needs-bump' && currentVersion) {
+                const manifestFile = currentTarget.type === 'asset' ? 'manifest.json' : 'bundle.json';
+                await updateManifestVersion(currentTarget.sourceDir, manifestFile, currentVersion);
+                if (cancelled)
+                    return;
+                // Re-read the target so it has the updated version
+                currentTarget = await detectPublishType(currentTarget.sourceDir);
+                if (cancelled)
+                    return;
+            }
+            // Persist user-entered tags/tools to the manifest file on disk (manifest-based assets only)
+            if (currentTarget.type === 'asset') {
+                const manifestFile = 'manifest.json';
+                if (state.promptTagsValue) {
+                    const parsedTags = state.promptTagsValue
+                        .split(',')
+                        .map((t) => t.trim())
+                        .filter(Boolean);
+                    if (parsedTags.length > 0) {
+                        await updateManifestField(currentTarget.sourceDir, manifestFile, 'tags', parsedTags);
+                        if (cancelled)
+                            return;
+                    }
+                }
+                if (state.selectedPromptTools.length > 0) {
+                    const parsedTools = state.selectedPromptTools.map((tool) => ({ tool }));
+                    await updateManifestField(currentTarget.sourceDir, manifestFile, 'tools', parsedTools);
+                    if (cancelled)
+                        return;
+                }
+            }
+            const publishPlan = await buildPublishPlan(currentTarget, currentVersion, state.isUpdate, state.flags.message);
+            if (cancelled)
+                return;
+            dispatch({ plan: publishPlan, type: 'PLAN_DONE' });
+        };
+        build().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: err instanceof Error ? err.message : String(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'building-plan'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: publishing ---
+    useEffect(() => {
+        if (state.phase !== 'publishing')
+            return;
+        if (!state.plan || !state.token)
+            return;
+        let cancelled = false;
+        const publish = async () => {
+            const progressCallback = (msg) => {
+                if (!cancelled) {
+                    dispatch({ message: msg, type: 'PUBLISH_PROGRESS' });
+                }
+            };
+            const result = await executePublish(state.plan, state.token, progressCallback);
+            if (cancelled)
+                return;
+            // Clear registry cache so subsequent commands see the new version
+            try {
+                await clearCache();
+            }
+            catch {
+                // Best-effort — don't fail publish over cache
+            }
+            // Update lockfile in-place when publishing from an installed asset
+            if (state.flags.fromInstalled || state.flags.update) {
+                try {
+                    const projectRoot = findProjectRoot(state.flags.projectRoot);
+                    const pubTools = await resolveTools(state.flags.tool);
+                    const pubAdapter = pubTools[0].adapter;
+                    await withLockfileLock(projectRoot, async () => {
+                        const lockfile = await readLockfile(projectRoot);
+                        const { name, org } = parseOrgFromName(state.flags.rawPath);
+                        const installed = findInstalledAsset(lockfile, name, undefined, org);
+                        if (installed) {
+                            const resolved = resolveInstalledPaths(installed, pubAdapter, projectRoot);
+                            const updatedFiles = await Promise.all(resolved.files.map(async (file) => ({
+                                checksum: await hashFile(join(projectRoot, file.installedPath)),
+                                sourcePath: file.sourcePath,
+                            })));
+                            const updatedLockfile = addAssetToLockfile(lockfile, {
+                                ...installed,
+                                files: updatedFiles,
+                                version: state.resolvedVersion,
+                            });
+                            await writeLockfile(projectRoot, updatedLockfile);
+                        }
+                    });
+                }
+                catch {
+                    // Best-effort — don't fail publish over lockfile update
+                }
+            }
+            if (cancelled)
+                return;
+            dispatch({ result, type: 'PUBLISH_DONE' });
+        };
+        publish().catch((err) => {
+            if (!cancelled) {
+                dispatch({ message: mapPublishError(err), type: 'ERROR' });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'publishing'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Phase: installing (auto-install raw publish to lockfile) ---
+    useEffect(() => {
+        if (state.phase !== 'installing')
+            return;
+        let cancelled = false;
+        const install = async () => {
+            try {
+                const projectRoot = findProjectRoot(state.flags.projectRoot);
+                await withLockfileLock(projectRoot, async () => {
+                    // Read current lockfile
+                    const lockfile = await readLockfile(projectRoot);
+                    // Compute checksums from actual project files (not staging copies)
+                    const files = [];
+                    for (const file of state.rawDetection.files) {
+                        const checksum = await hashFile(file.absolutePath);
+                        files.push({
+                            checksum,
+                            sourcePath: file.relativePath,
+                        });
+                    }
+                    // Build InstalledAsset entry
+                    const installedAsset = {
+                        files,
+                        installedAt: new Date().toISOString(),
+                        installReason: 'direct',
+                        name: state.rawDetection.name,
+                        org: state.orgValue || undefined,
+                        type: state.rawDetection.assetType,
+                        version: state.resolvedVersion || state.target?.data.version || '1.0.0',
+                    };
+                    // Add to lockfile and write
+                    const updatedLockfile = addAssetToLockfile(lockfile, installedAsset);
+                    await writeLockfile(projectRoot, updatedLockfile);
+                });
+                if (!cancelled) {
+                    dispatch({ type: 'INSTALL_DONE' });
+                }
+            }
+            catch {
+                // Publish already succeeded, so just warn and move to done
+                if (!cancelled) {
+                    dispatch({ type: 'INSTALL_DONE' });
+                }
+            }
+        };
+        install();
+        return () => {
+            cancelled = true;
+        };
+        // Phase-gated effect: only runs when entering 'installing'
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.phase]);
+    // --- Cleanup temp directory on error or done ---
+    useEffect(() => {
+        if (state.phase !== 'error' && state.phase !== 'done' && state.phase !== 'dry-run-result')
+            return;
+        if (tempDirRef.current) {
+            const dir = tempDirRef.current;
+            tempDirRef.current = null;
+            rm(dir, { force: true, recursive: true }).catch(() => {
+                // Best-effort cleanup — ignore errors
+            });
+        }
+    }, [state.phase]);
+    return [state, dispatch];
+}
+//# sourceMappingURL=usePublishState.js.map