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

package/build/commands/publish.js

@@ -1,25 +1,14 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text, useApp } from 'ink';
 import TextInput from 'ink-text-input';
-import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
 import { option } from 'pastel';
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useEffect } from 'react';
 import { z } from 'zod';
 import { DryRunBanner, Spinner } from '../components/index.js';
 import { CheckIcon } from '../components/StatusBadge.js';
-import { resolveInstalledPaths } from '../lib/adapter.js';
-import { getGitHubToken } from '../lib/auth.js';
-import { hashFile } from '../lib/checksum.js';
+import { usePublishState } from '../hooks/usePublishState.js';
 import { DEFAULT_REGISTRY_BRANCH } 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, executeDirectPublish, executePublish, isOrgAsset, mapPublishError, updateManifestVersion, validatePublishTarget, } from '../lib/publisher.js';
-import { clearCache, fetchRegistry } from '../lib/registry.js';
-import { resolveTool } from '../lib/tool-resolver.js';
+import { isOrgAsset } from '../lib/publisher.js';
 export const description = 'Publish an asset or bundle to the registry';
 export const options = z.object({
     description: z
@@ -61,550 +50,20 @@ export const args = z.tuple([
 ]);
 export default function Publish({ args: [rawPath], options: { description: descriptionFlag, dryRun, fromInstalled, message, tags: tagsFlag }, }) {
     const { exit } = useApp();
-    // Phase state machine
-    const [phase, setPhase] = useState(fromInstalled ? 'resolving-installed' : 'detecting');
-    // Data accumulated across phases
-    const [target, setTarget] = useState();
-    const [validation, setValidation] = useState();
-    const [versionCheck, setVersionCheck] = useState();
-    const [token, setToken] = useState();
-    const [isUpdate, setIsUpdate] = useState(false);
-    const [resolvedVersion, setResolvedVersion] = useState('');
-    const [plan, setPlan] = useState();
-    const [publishResult, setPublishResult] = useState();
-    const [progressMessage, setProgressMessage] = useState('');
-    // Interactive prompt values
-    const [confirmValue, setConfirmValue] = useState('');
-    const [bumpSelection, setBumpSelection] = useState('');
-    // Raw publish state
-    const [rawDetection, setRawDetection] = useState(null);
-    const [descriptionValue, setDescriptionValue] = useState('');
-    const [tagsValue, setTagsValue] = useState('');
-    const [authorValue, setAuthorValue] = useState('');
-    const [orgValue, setOrgValue] = useState('');
-    const [toolsDetected, setToolsDetected] = useState([]);
-    const [isRawPublish, setIsRawPublish] = useState(false);
-    const [metadataSubPhase, setMetadataSubPhase] = useState('description');
-    // Error and status
-    const [errorMessage, setErrorMessage] = useState('');
-    // Temp directory ref for --from-installed cleanup
-    const tempDirRef = useRef(null);
-    // When --from-installed is used, resolvedPath is set after resolving the installed asset
-    const [resolvedPath, setResolvedPath] = useState(fromInstalled ? '' : resolve(rawPath));
-    // ---------------------------------------------------------------------------
-    // Cleanup helper for temp directory
-    // ---------------------------------------------------------------------------
-    const cleanupTempDir = useCallback(async () => {
-        if (tempDirRef.current) {
-            try {
-                await rm(tempDirRef.current, { force: true, recursive: true });
-            }
-            catch {
-                // Best-effort cleanup — ignore errors
-            }
-            tempDirRef.current = null;
-        }
-    }, []);
-    // ---------------------------------------------------------------------------
-    // Phase: Resolving installed asset (--from-installed)
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'resolving-installed')
-            return;
-        let cancelled = false;
-        const resolveInstalled = async () => {
-            const assetName = rawPath;
-            const { name, org } = parseOrgFromName(assetName);
-            const projectRoot = findProjectRoot();
-            const { adapter } = await resolveTool(undefined);
-            const lockfile = await readLockfile(projectRoot);
-            const installed = findInstalledAsset(lockfile, name, undefined, org);
-            if (!installed) {
-                if (!cancelled) {
-                    setErrorMessage(`Asset '${assetName}' is not installed.`);
-                    setPhase('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) {
-                setResolvedPath(tempDir);
-                setPhase('detecting');
-            }
-        };
-        resolveInstalled().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(err instanceof Error ? err.message : String(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, rawPath]);
-    // ---------------------------------------------------------------------------
-    // Phase: Detecting asset vs bundle
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'detecting')
-            return;
-        let cancelled = false;
-        const detect = async () => {
-            // First, try manifest-based detection (existing flow)
-            try {
-                const detected = await detectPublishType(resolvedPath);
-                if (cancelled)
-                    return;
-                setTarget(detected);
-                setPhase('validating');
-                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) {
-                        setErrorMessage(manifestMsg);
-                        setPhase('error');
-                    }
-                    return;
-                }
-            }
-            // Manifest not found — attempt raw asset detection
-            try {
-                const { adapter } = await resolveTool(undefined);
-                if (cancelled)
-                    return;
-                const projectRoot = findProjectRoot();
-                const detection = await detectAssetFromPath(resolvedPath, adapter, projectRoot);
-                if (cancelled)
-                    return;
-                setRawDetection(detection);
-                setIsRawPublish(true);
-                // Pre-fill metadata
-                const author = (await getGitUserName()) ?? '';
-                if (cancelled)
-                    return;
-                setAuthorValue(author);
-                const lockfile = await readLockfile(projectRoot);
-                if (cancelled)
-                    return;
-                setOrgValue(lockfile.org ?? '');
-                const tools = await detectCompatibleTools(detection.assetType);
-                if (cancelled)
-                    return;
-                setToolsDetected(tools.map((t) => ({ tool: t })));
-                // Non-interactive mode: both --description and --tags flags provided
-                if (descriptionFlag && tagsFlag) {
-                    const tags = tagsFlag.split(',').map((t) => t.trim()).filter(Boolean);
-                    const stagingDir = await buildStagingArea(detection, {
-                        author,
-                        description: 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;
-                    setTarget(detected);
-                    setPhase('validating');
-                }
-                else {
-                    // Interactive mode — gather metadata from the user
-                    setPhase('gathering-metadata');
-                }
-            }
-            catch (rawError) {
-                if (!cancelled) {
-                    setErrorMessage(rawError instanceof Error ? rawError.message : String(rawError));
-                    setPhase('error');
-                }
-            }
-        };
-        detect().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(err instanceof Error ? err.message : String(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, resolvedPath, descriptionFlag, tagsFlag]);
-    // ---------------------------------------------------------------------------
-    // Phase: Gathering metadata — building staging area sub-phase
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'gathering-metadata' || metadataSubPhase !== 'building-staging')
-            return;
-        let cancelled = false;
-        const build = async () => {
-            // Parse tags from comma-separated string
-            const tags = tagsValue
-                .split(',')
-                .map((t) => t.trim())
-                .filter(Boolean);
-            // Build staging area
-            const stagingDir = await buildStagingArea(rawDetection, {
-                author: authorValue,
-                description: descriptionValue,
-                org: orgValue || undefined,
-                tags,
-                tools: 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;
-            setTarget(detectedTarget);
-            setPhase('validating');
-        };
-        build().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(err instanceof Error ? err.message : String(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, metadataSubPhase, authorValue, descriptionValue, orgValue, rawDetection, tagsValue, toolsDetected]);
-    // ---------------------------------------------------------------------------
-    // Phase: Validating manifest/bundle
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'validating')
-            return;
-        if (!target)
-            return;
-        let cancelled = false;
-        const validate = async () => {
-            const result = await validatePublishTarget(target);
-            if (cancelled)
-                return;
-            setValidation(result);
-            if (!result.valid) {
-                setErrorMessage(`Validation failed:\n${result.errors.map((e) => `  - ${e}`).join('\n')}`);
-                setPhase('error');
-                return;
-            }
-            setPhase('checking-registry');
-        };
-        validate().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(err instanceof Error ? err.message : String(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, target]);
-    // ---------------------------------------------------------------------------
-    // Phase: Checking registry for existing asset
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'checking-registry')
-            return;
-        if (!target)
-            return;
-        let cancelled = false;
-        const check = async () => {
-            const authToken = await getGitHubToken();
-            if (cancelled)
-                return;
-            setToken(authToken);
-            const reg = await fetchRegistry();
-            if (cancelled)
-                return;
-            const versionResult = checkRegistryVersion(target, reg);
-            if (cancelled)
-                return;
-            setVersionCheck(versionResult);
-            if (versionResult.status === 'new-asset') {
-                setIsUpdate(false);
-                setResolvedVersion(target.data.version);
-                setPhase('building-plan');
-            }
-            else if (versionResult.status === 'version-already-bumped') {
-                setIsUpdate(true);
-                setResolvedVersion(target.data.version);
-                setPhase('confirm-update');
-            }
-            else {
-                // needs-bump
-                setIsUpdate(true);
-                setPhase('bump-prompt');
-            }
-        };
-        check().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(mapPublishError(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, target]);
-    // ---------------------------------------------------------------------------
-    // Phase: Building publish plan
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'building-plan')
-            return;
-        if (!target)
-            return;
-        let cancelled = false;
-        const build = async () => {
-            const publishPlan = await buildPublishPlan(target, resolvedVersion, isUpdate, message);
-            if (cancelled)
-                return;
-            setPlan(publishPlan);
-            if (dryRun) {
-                setPhase('dry-run-result');
-            }
-            else {
-                setPhase('publishing');
-            }
-        };
-        build().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(err instanceof Error ? err.message : String(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, target, resolvedVersion, isUpdate, dryRun, message]);
-    // ---------------------------------------------------------------------------
-    // Phase: Publishing (executing git operations)
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'publishing')
-            return;
-        if (!plan || !token)
-            return;
-        let cancelled = false;
-        const publish = async () => {
-            const progressCallback = (msg) => {
-                if (!cancelled) {
-                    setProgressMessage(msg);
-                }
-            };
-            const result = isOrgAsset(plan)
-                ? await executeDirectPublish(plan, token, progressCallback)
-                : await executePublish(plan, token, progressCallback);
-            if (cancelled)
-                return;
-            setPublishResult(result);
-            // 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 (fromInstalled) {
-                try {
-                    const projectRoot = findProjectRoot();
-                    const { adapter: pubAdapter } = await resolveTool(undefined);
-                    await withLockfileLock(projectRoot, async () => {
-                        const lockfile = await readLockfile(projectRoot);
-                        const { name, org } = parseOrgFromName(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: resolvedVersion,
-                            });
-                            await writeLockfile(projectRoot, updatedLockfile);
-                        }
-                    });
-                }
-                catch {
-                    // Best-effort — don't fail publish over lockfile update
-                }
-            }
-            // Raw publishes need to be added to the lockfile
-            if (isRawPublish) {
-                setPhase('installing');
-            }
-            else {
-                setPhase('done');
-            }
-        };
-        publish().catch((err) => {
-            if (!cancelled) {
-                setErrorMessage(mapPublishError(err));
-                setPhase('error');
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, plan, token, fromInstalled, rawPath, resolvedVersion, isRawPublish]);
-    // ---------------------------------------------------------------------------
-    // Phase: Installing (auto-install raw publish to lockfile)
-    // ---------------------------------------------------------------------------
-    useEffect(() => {
-        if (phase !== 'installing')
-            return;
-        let cancelled = false;
-        const install = async () => {
-            try {
-                const projectRoot = findProjectRoot();
-                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 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: rawDetection.name,
-                        org: orgValue || undefined,
-                        type: rawDetection.assetType,
-                        version: resolvedVersion || target?.data.version || '1.0.0',
-                    };
-                    // Add to lockfile and write
-                    const updatedLockfile = addAssetToLockfile(lockfile, installedAsset);
-                    await writeLockfile(projectRoot, updatedLockfile);
-                });
-                if (!cancelled) {
-                    setPhase('done');
-                }
-            }
-            catch (error) {
-                // Publish already succeeded, so just warn and move to done
-                if (!cancelled) {
-                    console.error('Warning: Failed to update lockfile:', error);
-                    setPhase('done');
-                }
-            }
-        };
-        install();
-        return () => {
-            cancelled = true;
-        };
-    }, [phase, rawDetection, orgValue, resolvedVersion, target]);
-    // ---------------------------------------------------------------------------
-    // Prompt handlers
-    // ---------------------------------------------------------------------------
-    const handleConfirmSubmit = useCallback((value) => {
-        const trimmed = value.trim().toLowerCase();
-        if (trimmed === 'y' || trimmed === 'yes') {
-            setPhase('building-plan');
-        }
-        else if (trimmed === 'n' || trimmed === 'no') {
-            setErrorMessage('Publish cancelled.');
-            setPhase('error');
-        }
-        // Otherwise ignore (wait for valid input)
-    }, []);
-    const handleBumpSubmit = useCallback((value) => {
-        if (!target || !versionCheck || versionCheck.status !== 'needs-bump')
-            return;
-        const trimmed = value.trim().toLowerCase();
-        if (trimmed !== 'patch' && trimmed !== 'minor' && trimmed !== 'major') {
-            return; // Ignore invalid input
-        }
-        const bumpType = trimmed;
-        const newVersion = bumpVersion(versionCheck.latestVersion, bumpType);
-        setResolvedVersion(newVersion);
-        // Update the local manifest file
-        const manifestFile = target.type === 'asset' ? 'manifest.json' : 'bundle.json';
-        updateManifestVersion(target.sourceDir, manifestFile, newVersion)
-            .then(() => {
-            // Re-read the target so it has the updated version
-            return detectPublishType(target.sourceDir);
-        })
-            .then((updatedTarget) => {
-            setTarget(updatedTarget);
-            setPhase('building-plan');
-        })
-            .catch((err) => {
-            setErrorMessage(`Failed to update version: ${err instanceof Error ? err.message : String(err)}`);
-            setPhase('error');
-        });
-    }, [target, versionCheck]);
-    // ---------------------------------------------------------------------------
-    // Raw publish prompt handlers
-    // ---------------------------------------------------------------------------
-    const handleDescriptionSubmit = useCallback((value) => {
-        if (!value.trim())
-            return; // Don't allow empty description
-        setDescriptionValue(value.trim());
-        setMetadataSubPhase('tags');
-    }, []);
-    const handleTagsSubmit = useCallback((value) => {
-        setTagsValue(value);
-        setMetadataSubPhase('building-staging');
-    }, []);
+    const flags = {
+        descriptionFlag,
+        dryRun,
+        fromInstalled,
+        message,
+        rawPath,
+        tagsFlag,
+    };
+    const [state, dispatch] = usePublishState(flags);
     // ---------------------------------------------------------------------------
     // Exit on error
     // ---------------------------------------------------------------------------
     useEffect(() => {
-        if (phase === 'error') {
-            void cleanupTempDir();
+        if (state.phase === 'error') {
             const timer = setTimeout(() => {
                 process.exitCode = 1;
                 exit();
@@ -613,13 +72,12 @@ export default function Publish({ args: [rawPath], options: { description: descr
                 clearTimeout(timer);
             };
         }
-    }, [phase, exit, cleanupTempDir]);
+    }, [state.phase, exit]);
     // ---------------------------------------------------------------------------
     // Exit on done
     // ---------------------------------------------------------------------------
     useEffect(() => {
-        if (phase === 'done') {
-            void cleanupTempDir();
+        if (state.phase === 'done') {
             const timer = setTimeout(() => {
                 exit();
             }, 100);
@@ -627,13 +85,12 @@ export default function Publish({ args: [rawPath], options: { description: descr
                 clearTimeout(timer);
             };
         }
-    }, [phase, exit, cleanupTempDir]);
+    }, [state.phase, exit]);
     // ---------------------------------------------------------------------------
     // Exit on dry-run-result
     // ---------------------------------------------------------------------------
     useEffect(() => {
-        if (phase === 'dry-run-result') {
-            void cleanupTempDir();
+        if (state.phase === 'dry-run-result') {
             const timer = setTimeout(() => {
                 exit();
             }, 100);
@@ -641,64 +98,70 @@ export default function Publish({ args: [rawPath], options: { description: descr
                 clearTimeout(timer);
             };
         }
-    }, [phase, exit, cleanupTempDir]);
+    }, [state.phase, exit]);
     // ---------------------------------------------------------------------------
     // Render
     // ---------------------------------------------------------------------------
     // Error state
-    if (phase === 'error') {
-        return _jsxs(Text, { color: 'red', children: ["Error: ", errorMessage] });
+    if (state.phase === 'error') {
+        return _jsxs(Text, { color: 'red', children: ["Error: ", state.errorMessage] });
     }
     // Resolving installed asset
-    if (phase === 'resolving-installed') {
+    if (state.phase === 'resolving-installed') {
         return _jsx(Spinner, { message: 'Resolving installed asset...' });
     }
     // Detecting
-    if (phase === 'detecting') {
+    if (state.phase === 'detecting') {
         return _jsx(Spinner, { message: 'Detecting asset type...' });
     }
     // Gathering metadata (raw publish)
-    if (phase === 'gathering-metadata' && rawDetection) {
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["Detected: ", rawDetection.assetType, " \"", _jsx(Text, { bold: true, children: rawDetection.name }), "\" (", rawDetection.files.length, " file", rawDetection.files.length !== 1 ? 's' : '', ")"] }), _jsxs(Text, { children: ["Author: ", authorValue, " (from git config)"] }), orgValue && _jsxs(Text, { children: ["Org: ", orgValue, " (from lockfile)"] }), _jsx(Text, { children: " " }), metadataSubPhase === 'description' && (_jsxs(Box, { children: [_jsx(Text, { children: "Description: " }), _jsx(TextInput, { focus: true, onChange: setDescriptionValue, onSubmit: handleDescriptionSubmit, value: descriptionValue })] })), metadataSubPhase === 'tags' && (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["Description: ", descriptionValue] }), _jsxs(Box, { children: [_jsx(Text, { children: "Tags (comma-separated, optional): " }), _jsx(TextInput, { focus: true, onChange: setTagsValue, onSubmit: handleTagsSubmit, value: tagsValue })] })] })), metadataSubPhase === 'building-staging' && _jsx(Spinner, { message: 'Building staging area...' })] }));
+    if (state.phase === 'gathering-metadata' && state.rawDetection) {
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["Detected: ", state.rawDetection.assetType, " \"", _jsx(Text, { bold: true, children: state.rawDetection.name }), "\" (", state.rawDetection.files.length, " file", state.rawDetection.files.length !== 1 ? 's' : '', ")"] }), _jsxs(Text, { children: ["Author: ", state.authorValue, " (from git config)"] }), state.orgValue && _jsxs(Text, { children: ["Org: ", state.orgValue, " (from lockfile)"] }), _jsx(Text, { children: " " }), state.metadataSubPhase === 'description' && (_jsxs(Box, { children: [_jsx(Text, { children: "Description: " }), _jsx(TextInput, { focus: true, onChange: (v) => dispatch({ type: 'SET_DESCRIPTION', value: v }), onSubmit: () => dispatch({ type: 'SUBMIT_DESCRIPTION' }), value: state.descriptionValue })] })), state.metadataSubPhase === 'tags' && (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: ["Description: ", state.descriptionValue] }), _jsxs(Box, { children: [_jsx(Text, { children: "Tags (comma-separated, optional): " }), _jsx(TextInput, { focus: true, onChange: (v) => dispatch({ type: 'SET_TAGS', value: v }), onSubmit: () => dispatch({ type: 'SUBMIT_TAGS' }), value: state.tagsValue })] })] })), state.metadataSubPhase === 'building-staging' && _jsx(Spinner, { message: 'Building staging area...' })] }));
     }
     // Validating
-    if (phase === 'validating') {
+    if (state.phase === 'validating') {
         return _jsx(Spinner, { message: 'Validating manifest...' });
     }
     // Checking registry
-    if (phase === 'checking-registry') {
+    if (state.phase === 'checking-registry') {
         return _jsx(Spinner, { message: 'Checking registry...' });
     }
     // Confirm update prompt
-    if (phase === 'confirm-update' && target && versionCheck && versionCheck.status === 'version-already-bumped') {
-        return (_jsxs(Box, { flexDirection: 'column', children: [validation && (_jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Validation:" }), validation.errors.length === 0 && (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'pass' }), " All checks passed"] })), validation.warnings.map((w, i) => (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'warn' }), " ", w] }, i)))] })), _jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsxs(Text, { children: ["Asset ", _jsx(Text, { bold: true, children: target.data.name }), " already exists in the registry at v", versionCheck.latestVersion, "."] }), _jsxs(Text, { children: ["Publishing v", _jsx(Text, { bold: true, children: target.data.version }), " as an update."] })] }), _jsxs(Box, { children: [_jsx(Text, { color: 'cyan', children: '> ' }), _jsx(Text, { children: "Continue? (y/n): " }), _jsx(TextInput, { focus: true, onChange: setConfirmValue, onSubmit: handleConfirmSubmit, value: confirmValue })] })] }));
+    if (state.phase === 'confirm-update' &&
+        state.target &&
+        state.versionCheck &&
+        state.versionCheck.status === 'version-already-bumped') {
+        return (_jsxs(Box, { flexDirection: 'column', children: [state.validation && (_jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Validation:" }), state.validation.errors.length === 0 && (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'pass' }), " All checks passed"] })), state.validation.warnings.map((w, i) => (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'warn' }), " ", w] }, i)))] })), _jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsxs(Text, { children: ["Asset ", _jsx(Text, { bold: true, children: state.target.data.name }), " already exists in the registry at v", state.versionCheck.latestVersion, "."] }), _jsxs(Text, { children: ["Publishing v", _jsx(Text, { bold: true, children: state.target.data.version }), " as an update."] })] }), _jsxs(Box, { children: [_jsx(Text, { color: 'cyan', children: '> ' }), _jsx(Text, { children: "Continue? (y/n): " }), _jsx(TextInput, { focus: true, onChange: (v) => dispatch({ type: 'SET_CONFIRM_VALUE', value: v }), onSubmit: () => dispatch({ type: 'SUBMIT_CONFIRM' }), value: state.confirmValue })] })] }));
     }
     // Bump prompt
-    if (phase === 'bump-prompt' && target && versionCheck && versionCheck.status === 'needs-bump') {
-        return (_jsxs(Box, { flexDirection: 'column', children: [validation && (_jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Validation:" }), validation.errors.length === 0 && (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'pass' }), " All checks passed"] })), validation.warnings.map((w, i) => (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'warn' }), " ", w] }, i)))] })), _jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsxs(Text, { children: ["Asset ", _jsx(Text, { bold: true, children: target.data.name }), " exists in the registry at v", versionCheck.latestVersion, "."] }), _jsxs(Text, { children: ["Current manifest version (v", target.data.version, ") is not newer."] })] }), _jsxs(Box, { children: [_jsx(Text, { color: 'cyan', children: '> ' }), _jsx(Text, { children: "Bump type (patch/minor/major): " }), _jsx(TextInput, { focus: true, onChange: setBumpSelection, onSubmit: handleBumpSubmit, value: bumpSelection })] })] }));
+    if (state.phase === 'bump-prompt' &&
+        state.target &&
+        state.versionCheck &&
+        state.versionCheck.status === 'needs-bump') {
+        return (_jsxs(Box, { flexDirection: 'column', children: [state.validation && (_jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Validation:" }), state.validation.errors.length === 0 && (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'pass' }), " All checks passed"] })), state.validation.warnings.map((w, i) => (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'warn' }), " ", w] }, i)))] })), _jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsxs(Text, { children: ["Asset ", _jsx(Text, { bold: true, children: state.target.data.name }), " exists in the registry at v", state.versionCheck.latestVersion, "."] }), _jsxs(Text, { children: ["Current manifest version (v", state.target.data.version, ") is not newer."] })] }), _jsxs(Box, { children: [_jsx(Text, { color: 'cyan', children: '> ' }), _jsx(Text, { children: "Bump type (patch/minor/major): " }), _jsx(TextInput, { focus: true, onChange: (v) => dispatch({ type: 'SET_BUMP_SELECTION', value: v }), onSubmit: () => dispatch({ type: 'SUBMIT_BUMP' }), value: state.bumpSelection })] })] }));
     }
     // Building plan
-    if (phase === 'building-plan') {
+    if (state.phase === 'building-plan') {
         return _jsx(Spinner, { message: 'Building publish plan...' });
     }
     // Dry run result
-    if (phase === 'dry-run-result' && plan && target) {
-        const statusLabel = plan.isUpdate
-            ? `Update from v${versionCheck && versionCheck.status !== 'new-asset' ? versionCheck.latestVersion : '?'}`
+    if (state.phase === 'dry-run-result' && state.plan && state.target) {
+        const statusLabel = state.plan.isUpdate
+            ? `Update from v${state.versionCheck && state.versionCheck.status !== 'new-asset' ? state.versionCheck.latestVersion : '?'}`
             : 'New asset';
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'publish', count: plan.files.length, tool: 'registry' }), _jsx(Text, { children: " " }), validation && (_jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Validation:" }), validation.errors.length === 0 && (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'pass' }), " All checks passed"] })), validation.warnings.map((w, i) => (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'warn' }), " ", w] }, i)))] })), _jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Asset: " }), _jsx(Text, { bold: true, children: target.data.name })] }), target.type === 'asset' && target.assetType && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Type: " }), target.assetType] })), target.type === 'bundle' && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Type: " }), "bundle"] })), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Version: " }), plan.resolvedVersion] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Status: " }), statusLabel] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Checksum: " }), plan.checksum] })] }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Files to publish:" }), plan.files.map((file) => (_jsxs(Text, { children: [" ", file] }, file))), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Target: " }), plan.registryPath] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Branch: " }), plan.branchName] }), isOrgAsset(plan) ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Publish: " }), "Direct commit to ", DEFAULT_REGISTRY_BRANCH] })) : (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "PR Target:" }), " ", DEFAULT_REGISTRY_BRANCH] }))] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'publish', count: state.plan.files.length, tools: ['registry'] }), _jsx(Text, { children: " " }), state.validation && (_jsxs(Box, { flexDirection: 'column', marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Validation:" }), state.validation.errors.length === 0 && (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'pass' }), " All checks passed"] })), state.validation.warnings.map((w, i) => (_jsxs(Text, { children: ['  ', _jsx(CheckIcon, { status: 'warn' }), " ", w] }, i)))] })), _jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Asset: " }), _jsx(Text, { bold: true, children: state.target.data.name })] }), state.target.type === 'asset' && state.target.assetType && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Type: " }), state.target.assetType] })), state.target.type === 'bundle' && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Type: " }), "bundle"] })), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Version: " }), state.plan.resolvedVersion] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Status: " }), statusLabel] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Checksum: " }), state.plan.checksum] })] }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Files to publish:" }), state.plan.files.map((file) => (_jsxs(Text, { children: [" ", file] }, file))), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Target: " }), state.plan.registryPath] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Branch: " }), state.plan.branchName] }), isOrgAsset(state.plan) ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Publish: " }), "Direct commit to ", DEFAULT_REGISTRY_BRANCH] })) : (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "PR Target:" }), " ", DEFAULT_REGISTRY_BRANCH] }))] }));
     }
     // Publishing
-    if (phase === 'publishing') {
-        return _jsx(Spinner, { message: progressMessage || 'Publishing...' });
+    if (state.phase === 'publishing') {
+        return _jsx(Spinner, { message: state.progressMessage || 'Publishing...' });
     }
     // Installing (auto-install raw publish to lockfile)
-    if (phase === 'installing') {
+    if (state.phase === 'installing') {
         return _jsx(Spinner, { message: 'Adding to lockfile...' });
     }
     // Done
-    if (phase === 'done' && publishResult && target) {
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { color: 'green', children: ["Published ", _jsx(Text, { bold: true, children: target.data.name }), " v", resolvedVersion] }), isRawPublish && (_jsxs(Text, { color: 'green', children: ["Installed ", rawDetection?.name, "@", resolvedVersion || target.data.version || '1.0.0', " to lockfile"] })), _jsx(Text, { children: " " }), publishResult.mode === 'pr' ? (_jsxs(Text, { children: ["PR: ", _jsx(Text, { color: 'cyan', children: publishResult.prUrl })] })) : (_jsxs(Text, { children: ["Committed directly to ", _jsx(Text, { color: 'cyan', children: publishResult.branchName })] })), _jsxs(Text, { children: ["Branch: ", _jsx(Text, { dimColor: true, children: publishResult.branchName })] })] }));
+    if (state.phase === 'done' && state.publishResult && state.target) {
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { color: 'green', children: ["Published ", _jsx(Text, { bold: true, children: state.target.data.name }), " v", state.resolvedVersion] }), state.isRawPublish && (_jsxs(Text, { color: 'green', children: ["Installed ", state.rawDetection?.name, "@", state.resolvedVersion || state.target.data.version || '1.0.0', " to lockfile"] })), _jsx(Text, { children: " " }), state.publishResult.mode === 'pr' ? (_jsxs(Text, { children: ["PR: ", _jsx(Text, { color: 'cyan', children: state.publishResult.prUrl })] })) : (_jsxs(Text, { children: ["Committed directly to ", _jsx(Text, { color: 'cyan', children: state.publishResult.branchName })] })), _jsxs(Text, { children: ["Branch: ", _jsx(Text, { dimColor: true, children: state.publishResult.branchName })] })] }));
     }
     return null;
 }