aman-intelligence 0.1.0

package/dist/commands/doctor.d.ts

@@ -0,0 +1,4 @@
+export declare const DoctorApp: ({ onBack }: {
+    onBack?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function doctorCommand(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { doctorService } from '../services/doctor.service.js';
+import { HealthReport } from '../ui/components/HealthReport.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { theme } from '../ui/theme.js';
+import { useResponsiveLayout, MIN_COLUMNS, MIN_ROWS } from '../ui/layout.js';
+export const DoctorApp = ({ onBack }) => {
+    const { exit } = useApp();
+    const [checks, setChecks] = useState(null);
+    const { rows, columns, isTooSmall, isCompact, physicalColumns, physicalRows } = useResponsiveLayout();
+    useEffect(() => {
+        doctorService.runChecks('global').then((result) => {
+            setChecks(result);
+            if (!onBack) {
+                setTimeout(() => exit(), 300);
+            }
+        });
+    }, [exit, onBack]);
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            if (onBack)
+                onBack();
+            else
+                exit();
+        }
+    });
+    if (!checks) {
+        return (_jsx(Box, { paddingX: 1, flexDirection: "column", height: rows, justifyContent: "space-between", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Narrator, { state: "searching", compact: true }), _jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: "Running health checks..." }) })] }) }));
+    }
+    return (_jsxs(Box, { paddingX: 1, flexDirection: "column", height: rows, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.accent, children: "Terminal" }), _jsx(Text, { color: theme.borderMuted, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { children: ["Size: ", physicalColumns, "\u00D7", physicalRows] }), _jsxs(Text, { children: ["Mode: ", isCompact ? 'Compact' : 'Normal'] }), isTooSmall ? (_jsxs(Text, { color: theme.error, children: ["\u2717 Below minimum supported size (", MIN_COLUMNS, "x", MIN_ROWS, ")"] })) : (_jsx(Text, { color: theme.success, children: "\u2713 Supported" }))] }), _jsx(HealthReport, { checks: checks })] }), onBack && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.dim, children: "Press esc or q to go back" }) }))] }));
+};
+export async function doctorCommand() {
+    if (!process.stdin.isTTY) {
+        const checks = await doctorService.runChecks('global');
+        console.log('\n  Aman Diagnostics (Non-TTY Fallback):\n');
+        let allPassed = true;
+        for (const check of checks) {
+            const statusSymbol = check.status === 'pass' ? '✓' : check.status === 'warn' ? '⚠' : '✗';
+            console.log(`  ${statusSymbol} ${check.name}: ${check.message}`);
+            if (check.status === 'fail') {
+                allPassed = false;
+            }
+        }
+        console.log('');
+        if (!allPassed) {
+            process.exit(1);
+        }
+        return;
+    }
+    const { waitUntilExit } = render(_jsx(DoctorApp, {}));
+    await waitUntilExit();
+}

package/dist/commands/export.d.ts

@@ -0,0 +1 @@
+export declare function exportCommand(args: string[], options: any): Promise<void>;

package/dist/commands/export.js

@@ -0,0 +1,137 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { render, Box, useApp } from 'ink';
+import { packService } from '../services/pack.service.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { scanAll } from '../storage/scanner.js';
+import { environmentService } from '../services/environment.service.js';
+import { ASSET_TYPE_PLURAL } from '../ui/assetDisplay.js';
+import path from 'path';
+const ExportApp = ({ name, all, assetType }) => {
+    const { exit } = useApp();
+    const [state, setState] = useState('installing');
+    const [message, setMessage] = useState('Exporting...');
+    useEffect(() => {
+        async function doExport() {
+            try {
+                const envDir = environmentService.getActiveEnvironmentDir();
+                const data = await scanAll(envDir, 'global');
+                let skillsToExport = data.skills;
+                let promptsToExport = data.prompts;
+                let mcpsToExport = data.mcps;
+                let stacksToExport = data.stacks;
+                let exportName = name || 'aman-export';
+                if (assetType) {
+                    if (assetType === 'skill') {
+                        promptsToExport = [];
+                        mcpsToExport = [];
+                    }
+                    else if (assetType === 'prompt') {
+                        skillsToExport = [];
+                        mcpsToExport = [];
+                    }
+                    else {
+                        skillsToExport = [];
+                        promptsToExport = [];
+                    }
+                    stacksToExport = [];
+                    exportName = name || `${assetType}-export`;
+                }
+                if (name && !all && !assetType) {
+                    skillsToExport = data.skills.filter((s) => s.name === name);
+                    promptsToExport = data.prompts.filter((p) => p.name === name);
+                    mcpsToExport = data.mcps.filter((m) => m.name === name);
+                    stacksToExport = [];
+                    exportName = name;
+                    if (skillsToExport.length === 0 && promptsToExport.length === 0 && mcpsToExport.length === 0) {
+                        setState('error');
+                        setMessage(`Could not find asset "${name}"`);
+                        setTimeout(() => exit(), 1200);
+                        return;
+                    }
+                }
+                const packDef = {
+                    name: exportName,
+                    version: '1.0.0',
+                    description: all
+                        ? 'Full environment export'
+                        : assetType
+                            ? `Export of all ${ASSET_TYPE_PLURAL[assetType].toLowerCase()}`
+                            : `Export of ${exportName}`,
+                    skills: skillsToExport.map((s) => s.name),
+                    prompts: promptsToExport.map((p) => p.name),
+                    mcps: mcpsToExport.map((m) => m.name),
+                    stacks: stacksToExport.map((st) => st.name),
+                    createdAt: new Date().toISOString(),
+                };
+                const outPath = path.resolve(process.cwd(), `${exportName}.amanpack`);
+                await packService.create(exportName, packDef, outPath);
+                const total = packDef.skills.length + packDef.prompts.length + packDef.mcps.length;
+                const typeLabel = assetType ? ASSET_TYPE_PLURAL[assetType] : 'assets';
+                setState('success');
+                setMessage(`Exported ${total} ${typeLabel.toLowerCase()} → ${exportName}.amanpack`);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(`Error: ${err.message}`);
+            }
+            setTimeout(() => exit(), 1000);
+        }
+        doExport();
+    }, [all, assetType, exit, name]);
+    return (_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsx(Narrator, { state: state, message: message }) }));
+};
+function parseExportType(raw) {
+    if (!raw)
+        return undefined;
+    const t = raw.toLowerCase();
+    if (t === 'skill' || t === 'prompt' || t === 'mcp')
+        return t;
+    return undefined;
+}
+export async function exportCommand(args, options) {
+    const name = args[0];
+    const all = Boolean(options.all) || (!name && !options.type);
+    const assetType = parseExportType(options.type);
+    if (options.type && !assetType) {
+        console.log('  Usage: aman export [name] [--all] [--type skill|prompt|mcp]');
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        const envDir = environmentService.getActiveEnvironmentDir();
+        const data = await scanAll(envDir, 'global');
+        const skills = assetType === 'prompt' || assetType === 'mcp' ? [] : data.skills;
+        const prompts = assetType === 'skill' || assetType === 'mcp' ? [] : data.prompts;
+        const mcps = assetType === 'skill' || assetType === 'prompt' ? [] : data.mcps;
+        const total = skills.length + prompts.length + mcps.length;
+        if (!all && name && total === 0) {
+            console.error(`  No installed assets match "${name}".`);
+            process.exit(1);
+        }
+        if (all && total === 0) {
+            console.log('  No installed assets to export.');
+            return;
+        }
+        const packDef = {
+            name: name || 'aman-export',
+            version: '1.0.0',
+            description: 'CLI export',
+            skills: all ? skills.map((s) => s.name) : skills.filter((s) => s.name === name).map((s) => s.name),
+            prompts: all ? prompts.map((p) => p.name) : prompts.filter((p) => p.name === name).map((p) => p.name),
+            mcps: all ? mcps.map((m) => m.name) : mcps.filter((m) => m.name === name).map((m) => m.name),
+            stacks: [],
+            createdAt: new Date().toISOString(),
+        };
+        const exportTotal = packDef.skills.length + packDef.prompts.length + packDef.mcps.length;
+        if (exportTotal === 0) {
+            console.error(`  Could not find asset "${name}" to export.`);
+            process.exit(1);
+        }
+        const outPath = path.resolve(process.cwd(), `${packDef.name}.amanpack`);
+        await packService.create(packDef.name, packDef, outPath);
+        console.log(`  Exported ${exportTotal} asset(s) → ${outPath}`);
+        return;
+    }
+    const { waitUntilExit } = render(_jsx(ExportApp, { name: name, all: all, assetType: assetType }));
+    await waitUntilExit();
+}

package/dist/commands/help.d.ts

@@ -0,0 +1 @@
+export declare function helpCommand(): Promise<void>;

package/dist/commands/help.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render } from 'ink';
+import { useEffect } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { theme } from '../ui/theme.js';
+import { Header } from '../ui/components/Header.js';
+const HelpOutput = () => {
+    const { exit } = useApp();
+    useEffect(() => {
+        setTimeout(() => exit(), 100);
+    }, [exit]);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, marginY: 1, children: [_jsx(Header, { compact: true }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: theme.accent, children: "Usage" }) }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { children: "aman [command] [options]" }) })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: theme.accent, children: "Commands" }) }), [
+                        ['(none)', 'Open dashboard'],
+                        ['init', 'Set up local or GitHub-backed storage'],
+                        ['browse', 'Browse assets — skills, prompts, and MCPs'],
+                        ['search <query>', 'Universal search across all asset types'],
+                        ['info <name>', 'View details for any asset type'],
+                        ['install [name]', 'Install asset (wizard if no name). --type skill|prompt|mcp'],
+                        ['remove <name>', 'Remove an installed item'],
+                        ['update [name]', 'Update assets'],
+                        ['import <source>', 'Import from GitHub or a local folder'],
+                        ['export [name]', 'Export assets or environment (--all, --type skill|prompt|mcp)'],
+                        ['pack <cmd>', 'Create, inspect, or install shareable packs'],
+                        ['stack <cmd>', 'Manage workflow stacks'],
+                        ['sync <push|pull>', 'Push or pull environment from GitHub'],
+                        ['backup <cmd>', 'Save or restore your environment'],
+                        ['doctor', 'Check environment health'],
+                        ['config <cmd>', 'Manage settings'],
+                        ['registry <cmd>', 'Publish and query the canonical asset registry'],
+                        ['help', 'Show this help'],
+                    ].map(([cmd, desc]) => (_jsxs(Box, { children: [_jsx(Box, { width: 22, paddingLeft: 2, children: _jsx(Text, { color: theme.primary, children: cmd }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: desc }) })] }, cmd)))] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: theme.accent, children: "Registry" }) }), _jsx(Box, { paddingLeft: 2, marginBottom: 1, children: _jsx(Text, { color: theme.dim, children: "Canonical store for published asset versions (slug, checksum, immutability)." }) }), [
+                        ['registry publish', 'Publish an immutable asset version from a canonical directory'],
+                        ['registry deprecate', 'Mark a published version deprecated without removing it'],
+                        ['registry list', 'List all published versions for an asset slug'],
+                        ['registry search', 'Search published assets by name, slug, tags, or description'],
+                        ['registry resolve', 'Show metadata for an exact slug@version'],
+                    ].map(([cmd, desc]) => (_jsxs(Box, { children: [_jsx(Box, { width: 22, paddingLeft: 2, children: _jsx(Text, { color: theme.primary, children: cmd }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: desc }) })] }, cmd)))] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: theme.accent, children: "Global Options" }) }), _jsxs(Box, { children: [_jsx(Box, { width: 22, paddingLeft: 2, children: _jsx(Text, { color: theme.primary, children: "--global, -g" }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "Target global scope" }) })] }), _jsxs(Box, { children: [_jsx(Box, { width: 22, paddingLeft: 2, children: _jsx(Text, { color: theme.primary, children: "--project, -p" }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "Target project scope" }) })] }), _jsxs(Box, { children: [_jsx(Box, { width: 22, paddingLeft: 2, children: _jsx(Text, { color: theme.primary, children: "--github" }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "Use GitHub storage for init" }) })] }), _jsxs(Box, { children: [_jsx(Box, { width: 22, paddingLeft: 2, children: _jsx(Text, { color: theme.primary, children: "--local" }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "Use local storage for init" }) })] })] })] }));
+};
+export async function helpCommand() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        const { printHelpText } = await import('../cli/help-text.js');
+        printHelpText();
+        return;
+    }
+    const { waitUntilExit } = render(_jsx(HelpOutput, {}));
+    await waitUntilExit();
+}

package/dist/commands/import-wizard.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { AssetType } from '../types/index.js';
+import { DiscoveredImportAsset, TypeImportSelection } from '../import/types.js';
+export declare const ImportWizardApp: ({ onBack }: {
+    onBack?: () => void;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export declare function useImportPickInput(enabled: boolean, group: DiscoveredImportAsset[], pickCursor: number, setSelections: React.Dispatch<React.SetStateAction<Record<AssetType, TypeImportSelection>>>, activeType: AssetType, setPickCursor: React.Dispatch<React.SetStateAction<number>>): void;

package/dist/commands/import-wizard.js

@@ -0,0 +1,374 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { CustomSelectInput } from '../ui/components/CustomSelect.js';
+import { ScopePrompt } from '../ui/components/ScopePrompt.js';
+import { Header } from '../ui/components/Header.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { ProgressBar } from '../ui/animations/ProgressBar.js';
+import { theme } from '../ui/theme.js';
+import { assetTypeBadge, ASSET_TYPE_PLURAL } from '../ui/assetDisplay.js';
+import { useResponsiveLayout, MIN_COLUMNS, MIN_ROWS } from '../ui/layout.js';
+import { TooSmallScreen } from '../ui/components/TooSmallScreen.js';
+import { importDiscoveryService } from '../import/discovery.service.js';
+import { applyAutoRenameConflicts, detectImportConflicts, executeImportPlan, isGithubDestinationAvailable, summarizeByType, } from '../import/import.service.js';
+import { ASSET_TAB_ORDER } from '../ui/assetDisplay.js';
+const TYPE_ORDER = ASSET_TAB_ORDER;
+function defaultTypeSelections() {
+    return {
+        skill: { mode: 'all', selectedIds: new Set() },
+        prompt: { mode: 'all', selectedIds: new Set() },
+        mcp: { mode: 'all', selectedIds: new Set() },
+    };
+}
+function canonicalLabel(status) {
+    if (status === 'canonical')
+        return 'canonical';
+    if (status === 'convertible')
+        return 'convertible';
+    if (status === 'ambiguous')
+        return 'ambiguous';
+    return 'unknown';
+}
+function applyTypeSelections(assets, selections) {
+    const out = [];
+    for (const type of TYPE_ORDER) {
+        const group = assets.filter((a) => a.type === type);
+        const sel = selections[type];
+        if (sel.mode === 'skip' || group.length === 0)
+            continue;
+        if (sel.mode === 'all') {
+            out.push(...group);
+            continue;
+        }
+        out.push(...group.filter((a) => sel.selectedIds.has(a.id)));
+    }
+    return out;
+}
+export const ImportWizardApp = ({ onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const { isTooSmall, isCompact, physicalColumns, physicalRows, rows } = useResponsiveLayout();
+    const [step, setStep] = useState('source');
+    const [adapters, setAdapters] = useState([]);
+    const [sourceId, setSourceId] = useState(null);
+    const [customPath, setCustomPath] = useState('');
+    const [discovered, setDiscovered] = useState([]);
+    const [typeSelections, setTypeSelections] = useState(defaultTypeSelections());
+    const [typeQueueIndex, setTypeQueueIndex] = useState(0);
+    const typesWithAssets = useMemo(() => TYPE_ORDER.filter((t) => discovered.some((d) => d.type === t)), [discovered]);
+    const [pickCursor, setPickCursor] = useState(0);
+    const [destination, setDestination] = useState('local');
+    const [scope, setScope] = useState();
+    const [conflicts, setConflicts] = useState([]);
+    const [conflictBulkMode, setConflictBulkMode] = useState('ask');
+    const [conflictCursor, setConflictCursor] = useState(0);
+    const [state, setState] = useState('idle');
+    const [message, setMessage] = useState('');
+    const [progress, setProgress] = useState(0);
+    const [resultSummary, setResultSummary] = useState('');
+    const githubReady = isGithubDestinationAvailable();
+    const selectedItems = useMemo(() => applyTypeSelections(discovered, typeSelections), [discovered, typeSelections]);
+    const counts = useMemo(() => summarizeByType(selectedItems), [selectedItems]);
+    const activeType = typesWithAssets[typeQueueIndex] ?? null;
+    const activeGroup = activeType ? discovered.filter((a) => a.type === activeType) : [];
+    useImportPickInput(step === 'type-select' && activeType !== null && typeSelections[activeType].mode === 'select', activeGroup, pickCursor, setTypeSelections, activeType ?? 'skill', setPickCursor);
+    useEffect(() => {
+        setAdapters(importDiscoveryService.listAdapters());
+    }, []);
+    useInput((input, key) => {
+        if (input === 'q' || (key.escape && step === 'source')) {
+            handleExit();
+        }
+        else if (key.escape && step !== 'importing') {
+            if (step === 'custom-path')
+                setStep('source');
+            else if (step === 'type-select')
+                setStep('results');
+            else if (step === 'results')
+                setStep('source');
+            else if (step === 'destination')
+                setStep('results');
+            else if (step === 'scope')
+                setStep('destination');
+            else if (step === 'conflict-bulk')
+                setStep('scope');
+            else if (step === 'conflict-item')
+                setStep('conflict-bulk');
+            else if (step === 'confirm')
+                setStep(conflicts.length ? 'conflict-bulk' : 'scope');
+        }
+    });
+    async function runScan(id, rootPath) {
+        setStep('scanning');
+        setState('searching');
+        setMessage('Scanning for assets...');
+        try {
+            const items = await importDiscoveryService.scan(id, rootPath ? { rootPath } : undefined);
+            setDiscovered(items);
+            setTypeSelections(defaultTypeSelections());
+            setTypeQueueIndex(0);
+            setStep('results');
+        }
+        catch (err) {
+            setState('error');
+            setMessage(err instanceof Error ? err.message : String(err));
+            setStep('done');
+        }
+    }
+    async function prepareConflicts(nextScope) {
+        const items = applyTypeSelections(discovered, typeSelections);
+        const found = await detectImportConflicts(items, nextScope);
+        const withRename = applyAutoRenameConflicts(found, 'suffix');
+        setConflicts(withRename);
+        setScope(nextScope);
+        setConflictCursor(0);
+        setConflictBulkMode('ask');
+        if (withRename.length > 0)
+            setStep('conflict-bulk');
+        else
+            setStep('confirm');
+    }
+    function advanceTypeQueue() {
+        if (typeQueueIndex + 1 < typesWithAssets.length) {
+            setTypeQueueIndex((i) => i + 1);
+            setPickCursor(0);
+        }
+        else {
+            setStep('destination');
+        }
+    }
+    useEffect(() => {
+        if (step !== 'importing' || !scope || !sourceId)
+            return;
+        async function run() {
+            if (!sourceId || !scope)
+                return;
+            setState('installing');
+            setMessage('Importing assets...');
+            setProgress(10);
+            try {
+                const plan = {
+                    sourceId,
+                    sourceLabel: adapters.find((a) => a.id === sourceId)?.label ?? sourceId,
+                    destination,
+                    scope,
+                    items: selectedItems,
+                    conflicts,
+                };
+                const result = await executeImportPlan(plan);
+                setProgress(100);
+                setState('success');
+                setResultSummary(`Imported ${result.imported} · skipped ${result.skipped} · renamed ${result.renamed} · overwritten ${result.overwritten}`);
+                setMessage(`Import complete → ${scope}`);
+                setStep('done');
+                setTimeout(() => handleExit(), 2000);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(err instanceof Error ? err.message : String(err));
+                setStep('done');
+            }
+        }
+        run();
+    }, [step, scope, sourceId, destination, selectedItems, conflicts, adapters]);
+    if (isTooSmall) {
+        return (_jsx(TooSmallScreen, { columns: physicalColumns, rows: physicalRows, minColumns: MIN_COLUMNS, minRows: MIN_ROWS }));
+    }
+    if (step === 'scanning' || step === 'importing' || (step === 'done' && state !== 'idle')) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: state, message: message }), step === 'importing' && (_jsx(Box, { marginTop: 1, children: _jsx(ProgressBar, { progress: progress }) })), resultSummary && step === 'done' && (_jsx(Text, { color: theme.dim, children: resultSummary }))] }));
+    }
+    if (step === 'source') {
+        const items = adapters
+            .filter((a) => a.available)
+            .map((a) => ({ label: a.label, value: a.id }));
+        const unavailable = adapters.filter((a) => !a.available);
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, color: theme.accent, children: "Import from another tool" }), _jsx(Text, { color: theme.dim, children: "Choose where to import skills, prompts, and MCPs from" }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: items, onSelect: (item) => {
+                            setSourceId(item.value);
+                            if (item.value === 'custom-path' || item.value === 'local-folder')
+                                setStep('custom-path');
+                            else
+                                void runScan(item.value);
+                        } }) }), unavailable.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.dim, children: "Unavailable on this machine:" }), unavailable.map((a) => (_jsxs(Text, { color: theme.dim, wrap: "truncate", children: [a.label, ": ", a.unavailableReason] }, a.id)))] })), !isCompact && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.dim, children: "\u2191\u2193 navigate \u00B7 Enter select \u00B7 Esc/q back" }) }))] }));
+    }
+    if (step === 'custom-path') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: "Folder path" }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { color: theme.primary, children: "\u276F " }), _jsx(TextInput, { value: customPath, onChange: setCustomPath, onSubmit: () => {
+                                if (!sourceId)
+                                    return;
+                                void runScan(sourceId, customPath.trim() || process.cwd());
+                            }, placeholder: "./path-to-assets" })] }), _jsx(Text, { color: theme.dim, children: "Enter path \u00B7 Enter submit \u00B7 Esc back" })] }));
+    }
+    if (step === 'results') {
+        const byType = TYPE_ORDER.map((t) => ({
+            type: t,
+            items: discovered.filter((a) => a.type === t),
+        }));
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: "Discovered assets" }), _jsxs(Text, { color: theme.dim, children: ["Source: ", adapters.find((a) => a.id === sourceId)?.label ?? sourceId] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [byType.map(({ type, items }) => (_jsxs(Text, { children: [assetTypeBadge(type), " ", ASSET_TYPE_PLURAL[type], ": ", items.length] }, type))), discovered.length === 0 && (_jsx(Text, { color: theme.warning, children: "No recognizable assets found at this source." }))] }), !isCompact && discovered.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [discovered.slice(0, 8).map((item) => (_jsxs(Text, { color: theme.dim, wrap: "truncate", children: [assetTypeBadge(item.type), " ", item.name, " \u2014 ", canonicalLabel(item.canonicalStatus), " \u2014 ", item.originLabel, item.canonicalNote ? ` (${item.canonicalNote})` : ''] }, item.id))), discovered.length > 8 && (_jsxs(Text, { color: theme.dim, children: ["\u2026and ", discovered.length - 8, " more"] }))] })), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                            { label: discovered.length ? 'Configure import selection' : 'Choose another source', value: discovered.length ? 'select' : 'back' },
+                            ...(discovered.length ? [{ label: 'Import all discovered assets', value: 'all' }] : []),
+                        ], onSelect: (item) => {
+                            if (item.value === 'back') {
+                                setStep('source');
+                                return;
+                            }
+                            if (item.value === 'all') {
+                                setTypeSelections({
+                                    skill: { mode: 'all', selectedIds: new Set() },
+                                    prompt: { mode: 'all', selectedIds: new Set() },
+                                    mcp: { mode: 'all', selectedIds: new Set() },
+                                });
+                                setStep('destination');
+                                return;
+                            }
+                            setStep('type-select');
+                            setTypeQueueIndex(0);
+                            setPickCursor(0);
+                        } }) })] }));
+    }
+    if (step === 'type-select' && activeType) {
+        const group = discovered.filter((a) => a.type === activeType);
+        const sel = typeSelections[activeType];
+        if (sel.mode === 'select') {
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, children: ["Select ", ASSET_TYPE_PLURAL[activeType].toLowerCase(), " (", typeQueueIndex + 1, "/", typesWithAssets.length, ")"] }), _jsx(Text, { color: theme.dim, children: "Space toggle \u00B7 Enter done \u00B7 Esc back" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: group.map((item, idx) => {
+                            const picked = sel.selectedIds.has(item.id);
+                            return (_jsxs(Text, { color: idx === pickCursor ? theme.primary : theme.dim, children: [picked ? '◉' : '○', " ", item.name, " \u2014 ", item.originLabel] }, item.id));
+                        }) }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [{ label: 'Done selecting this type', value: 'done' }], onSelect: () => advanceTypeQueue() }) })] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, children: [ASSET_TYPE_PLURAL[activeType], " (", group.length, " found) \u2014 step ", typeQueueIndex + 1, "/", typesWithAssets.length] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                            { label: `Import all ${ASSET_TYPE_PLURAL[activeType].toLowerCase()}`, value: 'all' },
+                            { label: `Select specific ${ASSET_TYPE_PLURAL[activeType].toLowerCase()}`, value: 'select' },
+                            { label: `Skip ${ASSET_TYPE_PLURAL[activeType].toLowerCase()}`, value: 'skip' },
+                        ], onSelect: (item) => {
+                            const mode = item.value;
+                            setTypeSelections((prev) => ({
+                                ...prev,
+                                [activeType]: {
+                                    mode,
+                                    selectedIds: new Set(mode === 'select' ? group.map((g) => g.id) : []),
+                                },
+                            }));
+                            if (mode === 'select') {
+                                setPickCursor(0);
+                                return;
+                            }
+                            advanceTypeQueue();
+                        } }) })] }));
+    }
+    if (step === 'destination') {
+        const destItems = [
+            { label: 'Local environment', value: 'local' },
+        ];
+        if (githubReady) {
+            destItems.push({ label: 'GitHub-backed environment', value: 'github' });
+        }
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: "Destination" }), _jsxs(Text, { color: theme.dim, children: ["Selected: ", selectedItems.length, " assets (", counts.skill, " skills \u00B7 ", counts.prompt, " prompts \u00B7 ", counts.mcp, " MCPs)"] }), !githubReady && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.warning, children: "GitHub is not configured. Use `aman init --github` or connect GitHub first." }), _jsx(Text, { color: theme.dim, children: "Only Local destination is available." })] })), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: destItems, onSelect: (item) => {
+                            setDestination(item.value);
+                            setStep('scope');
+                        } }) })] }));
+    }
+    if (step === 'scope') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: "Scope" }), _jsx(Text, { color: theme.dim, children: "Where should imported assets be installed?" }), _jsx(Box, { marginTop: 1, children: _jsx(ScopePrompt, { onSelect: (s) => {
+                            void prepareConflicts(s);
+                        } }) })] }));
+    }
+    if (step === 'conflict-bulk') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, color: theme.warning, children: ["Name conflicts detected (", conflicts.length, ")"] }), _jsx(Text, { color: theme.dim, children: "Existing assets with the same name \u2014 choose how to resolve" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [conflicts.slice(0, isCompact ? 4 : 8).map((c) => (_jsxs(Text, { color: theme.dim, wrap: "truncate", children: [assetTypeBadge(c.asset.type), " ", c.asset.name, " \u2192 conflicts with \"", c.existingLocalName, "\""] }, c.asset.id))), conflicts.length > (isCompact ? 4 : 8) && (_jsxs(Text, { color: theme.dim, children: ["\u2026and ", conflicts.length - (isCompact ? 4 : 8), " more"] }))] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                            { label: 'Ask for each conflict', value: 'ask' },
+                            { label: 'Rename all conflicting items', value: 'rename-all' },
+                            { label: 'Skip all conflicting items', value: 'skip-all' },
+                            { label: 'Replace all existing items', value: 'replace-all' },
+                        ], onSelect: (item) => {
+                            const mode = item.value;
+                            setConflictBulkMode(mode);
+                            if (mode === 'rename-all') {
+                                setConflicts(applyAutoRenameConflicts(conflicts, 'suffix'));
+                                setStep('confirm');
+                            }
+                            else if (mode === 'skip-all') {
+                                setConflicts(conflicts.map((c) => ({ ...c, resolution: 'skip' })));
+                                setStep('confirm');
+                            }
+                            else if (mode === 'replace-all') {
+                                setConflicts(conflicts.map((c) => ({ ...c, resolution: 'overwrite', resolvedName: c.existingLocalName })));
+                                setStep('confirm');
+                            }
+                            else {
+                                // ask mode — walk through each conflict
+                                setConflictCursor(0);
+                                setStep('conflict-item');
+                            }
+                        } }) })] }));
+    }
+    if (step === 'conflict-item' && conflictCursor < conflicts.length) {
+        const c = conflicts[conflictCursor];
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, color: theme.warning, children: ["Conflict ", conflictCursor + 1, " of ", conflicts.length] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [assetTypeBadge(c.asset.type), " ", _jsx(Text, { bold: true, children: c.asset.name }), " already exists as \"", c.existingLocalName, "\""] }), _jsxs(Text, { color: theme.dim, children: ["Source: ", c.asset.originLabel] })] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                            { label: `Rename to "${c.resolvedName}"`, value: 'rename' },
+                            { label: 'Skip this asset', value: 'skip' },
+                            { label: 'Replace existing', value: 'replace' },
+                        ], onSelect: (item) => {
+                            const updated = [...conflicts];
+                            if (item.value === 'rename') {
+                                updated[conflictCursor] = { ...c, resolution: 'rename' };
+                            }
+                            else if (item.value === 'skip') {
+                                updated[conflictCursor] = { ...c, resolution: 'skip' };
+                            }
+                            else {
+                                updated[conflictCursor] = { ...c, resolution: 'overwrite', resolvedName: c.existingLocalName };
+                            }
+                            setConflicts(updated);
+                            if (conflictCursor + 1 < conflicts.length) {
+                                setConflictCursor(conflictCursor + 1);
+                            }
+                            else {
+                                setStep('confirm');
+                            }
+                        } }) })] }));
+    }
+    if (step === 'confirm') {
+        const renames = conflicts.filter((c) => c.resolution === 'rename').length;
+        const skips = conflicts.filter((c) => c.resolution === 'skip').length;
+        const replaces = conflicts.filter((c) => c.resolution === 'overwrite').length;
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: "Confirm import" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["Source:      ", _jsx(Text, { bold: true, children: adapters.find((a) => a.id === sourceId)?.label })] }), _jsxs(Text, { children: ["Skills:      ", _jsx(Text, { bold: true, color: theme.primary, children: counts.skill })] }), _jsxs(Text, { children: ["Prompts:     ", _jsx(Text, { bold: true, color: theme.success, children: counts.prompt })] }), _jsxs(Text, { children: ["MCPs:        ", _jsx(Text, { bold: true, color: theme.warning, children: counts.mcp })] }), _jsxs(Text, { children: ["Destination: ", destination === 'github' ? 'GitHub environment' : 'Local'] }), _jsxs(Text, { children: ["Scope:       ", scope] }), conflicts.length > 0 && (_jsxs(Text, { children: ["Conflicts:   ", renames > 0 ? `${renames} rename` : '', skips > 0 ? `${renames > 0 ? ' · ' : ''}${skips} skip` : '', replaces > 0 ? `${renames > 0 || skips > 0 ? ' · ' : ''}${replaces} replace` : ''] }))] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                            { label: 'Import now', value: 'go' },
+                            { label: 'Cancel', value: 'cancel' },
+                        ], onSelect: (item) => {
+                            if (item.value === 'cancel') {
+                                handleExit();
+                                return;
+                            }
+                            setStep('importing');
+                        } }) })] }));
+    }
+    return null;
+};
+// Space toggle handler for type-select pick mode
+export function useImportPickInput(enabled, group, pickCursor, setSelections, activeType, setPickCursor) {
+    useInput((input, key) => {
+        if (!enabled)
+            return;
+        if (key.upArrow)
+            setPickCursor((p) => Math.max(0, p - 1));
+        if (key.downArrow)
+            setPickCursor((p) => Math.min(group.length - 1, p + 1));
+        if (input === ' ') {
+            const id = group[pickCursor]?.id;
+            if (!id)
+                return;
+            setSelections((prev) => {
+                const next = new Set(prev[activeType].selectedIds);
+                if (next.has(id))
+                    next.delete(id);
+                else
+                    next.add(id);
+                return { ...prev, [activeType]: { ...prev[activeType], selectedIds: next } };
+            });
+        }
+    });
+}