aman-intelligence 0.1.0

package/dist/commands/import.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Scope } from '../types/index.js';
+export interface ImportAppProps {
+    source: string;
+    initialScope?: Scope;
+    onBack?: () => void;
+}
+export declare const ImportApp: React.FC<ImportAppProps>;
+export declare function importCommand(args: string[], options: any): Promise<void>;

package/dist/commands/import.js

@@ -0,0 +1,351 @@
+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 { CustomSelectInput } from '../ui/components/CustomSelect.js';
+import { githubService } from '../services/github.service.js';
+import { classificationService } from '../services/classification.service.js';
+import { assetService } from '../services/asset.service.js';
+import { ScopePrompt } from '../ui/components/ScopePrompt.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+import { averageConfidence, assetTypeBadge } from '../ui/assetDisplay.js';
+import { removeDir, isPathSafe } from '../storage/filesystem.js';
+import path from 'path';
+import { ProgressBar } from '../ui/animations/ProgressBar.js';
+import { TransitionScreen } from '../ui/animations/TransitionScreen.js';
+import { ImportWizardApp } from './import-wizard.js';
+import { importDiscoveryService } from '../import/discovery.service.js';
+import { applyAutoRenameConflicts, detectImportConflicts, executeImportPlan, isGithubDestinationAvailable, } from '../import/import.service.js';
+import { environmentService } from '../services/environment.service.js';
+export const ImportApp = ({ source, initialScope, onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const [mode, setMode] = useState('cloning');
+    const [state, setState] = useState('searching');
+    const [message, setMessage] = useState(`Cloning ${source}...`);
+    const [tempDir, setTempDir] = useState('');
+    const [classifications, setClassifications] = useState([]);
+    const [scope, setScope] = useState(initialScope);
+    const [progress, setProgress] = useState(0);
+    useInput((input, key) => {
+        if (input === 'q' || key.escape) {
+            if (tempDir)
+                removeDir(tempDir).catch(() => { });
+            handleExit();
+        }
+    });
+    // Step 1: Clone
+    useEffect(() => {
+        async function clone() {
+            try {
+                const dir = await githubService.import(source);
+                setTempDir(dir);
+                setMode('scanning');
+                setMessage(`Scanning ${source}...`);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(`Error: ${err.message}`);
+                setMode('done');
+                setTimeout(() => handleExit(), 1800);
+            }
+        }
+        clone();
+    }, [source]);
+    // Step 2: Classify
+    useEffect(() => {
+        if (mode !== 'scanning' || !tempDir)
+            return;
+        async function classify() {
+            const results = await classificationService.classifyDirectory(tempDir);
+            setClassifications(results);
+            setMode('preview');
+        }
+        classify();
+    }, [mode, tempDir]);
+    // Step 3: Install after scope selection
+    useEffect(() => {
+        if (mode !== 'installing' || !scope || !tempDir)
+            return;
+        const targetScope = scope;
+        async function install() {
+            setState('installing');
+            const highConf = classificationService.highConfidence(classifications);
+            let installed = 0;
+            let processed = 0;
+            for (const c of highConf) {
+                let filePath = path.resolve(tempDir, c.file);
+                // Priority 2: Security check
+                const safe = await isPathSafe(filePath, tempDir);
+                if (!safe) {
+                    setState('error');
+                    setMessage(`Security Error: Path traversal escape attempt detected inside file: ${c.file}`);
+                    setMode('done');
+                    setTimeout(() => handleExit(), 3000);
+                    return;
+                }
+                let baseName = c.file.replace(/\.[^.]+$/, '').replace(/[/\\]/g, '-');
+                if (c.type === 'skill') {
+                    filePath = path.dirname(filePath);
+                    if (filePath === tempDir) {
+                        baseName = path.basename(source).replace(/\.git$/, '');
+                    }
+                    else {
+                        baseName = path.basename(filePath);
+                    }
+                }
+                try {
+                    if (c.type === 'skill' || c.type === 'prompt' || c.type === 'mcp') {
+                        // Priority 4: Collision safety check
+                        const existingAssets = await assetService.list(c.type, targetScope);
+                        let name = baseName;
+                        let suffix = 1;
+                        while (existingAssets.some((item) => item.name === name)) {
+                            name = `${baseName}-${suffix}`;
+                            suffix++;
+                        }
+                        const metadataOverride = {};
+                        if (name !== baseName) {
+                            metadataOverride.originalName = baseName;
+                            metadataOverride.resolvedName = name;
+                        }
+                        await assetService.install(name, c.type, targetScope, filePath, source, metadataOverride);
+                        installed++;
+                    }
+                    // Remember classification for future syncs
+                    await classificationService.remember(c.file, c.type);
+                }
+                catch {
+                    // Skip failures silently
+                }
+                processed++;
+                setProgress(Math.round((processed / highConf.length) * 100));
+            }
+            setState('success');
+            setMessage(`Imported ${installed} assets → ${scope === 'project' ? 'project' : 'global'}`);
+            setMode('done');
+            // Cleanup
+            await removeDir(tempDir).catch(() => { });
+            setTimeout(() => handleExit(), 1200);
+        }
+        install();
+    }, [mode, scope, tempDir, classifications]);
+    // Cloning / scanning
+    if (mode === 'cloning' || mode === 'scanning') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: state, message: message })] }));
+    }
+    // Installing / done
+    if (mode === 'installing' || mode === 'done') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Narrator, { state: state, message: message }), mode === 'installing' && (_jsx(Box, { marginTop: 1, children: _jsx(ProgressBar, { progress: progress }) }))] }));
+    }
+    // Scope selection
+    if (mode === 'scope') {
+        const summary = classificationService.summarize(classificationService.highConfidence(classifications));
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { children: ["Import ", summary.skills + summary.prompts + summary.mcps, " assets"] }), _jsx(Box, { marginTop: 1, children: _jsx(ScopePrompt, { onSelect: (s) => { setScope(s); setMode('installing'); } }) })] }));
+    }
+    // Preview
+    if (mode === 'preview') {
+        const summary = classificationService.summarize(classifications);
+        const lowConf = classificationService.lowConfidence(classifications);
+        const reviewItems = [
+            { label: 'Continue', value: 'continue' },
+            ...(lowConf.length > 0 ? [{ label: `Review ${lowConf.length} unknown files`, value: 'review' }] : []),
+        ];
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, children: ["Detected Assets in ", source, ":"] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["  Skills: ", _jsx(Text, { color: theme.primary, bold: true, children: summary.skills })] }), _jsxs(Text, { children: ["  Prompts: ", _jsx(Text, { color: theme.success, bold: true, children: summary.prompts })] }), _jsxs(Text, { children: ["  MCPs: ", _jsx(Text, { color: theme.warning, bold: true, children: summary.mcps })] }), summary.stacks > 0 && _jsxs(Text, { children: ["  Stacks: ", _jsx(Text, { color: theme.accent, bold: true, children: summary.stacks })] }), summary.unknown > 0 && _jsxs(Text, { children: ["  Unknown: ", _jsx(Text, { color: theme.dim, children: summary.unknown })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ['  ', "Confidence (auto-import \u226550%):", ' ', _jsxs(Text, { bold: true, color: theme.primary, children: [averageConfidence(classificationService.highConfidence(classifications)), "%"] })] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.dim, children: "Ready to import:" }), classificationService.highConfidence(classifications).slice(0, 10).map((c, i) => (_jsxs(Text, { color: theme.dim, children: ['  ', c.type === 'skill' || c.type === 'prompt' || c.type === 'mcp'
+                                            ? assetTypeBadge(c.type)
+                                            : `[${c.type}]`, ' ', c.file, " \u2014 ", c.confidence, "% (", c.reason, ")"] }, i))), classificationService.highConfidence(classifications).length > 10 && (_jsxs(Text, { color: theme.dim, children: ['  ', "\u2026and ", classificationService.highConfidence(classifications).length - 10, " more"] }))] })] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: reviewItems, onSelect: (item) => {
+                            if (item.value === 'continue') {
+                                if (initialScope) {
+                                    setScope(initialScope);
+                                    setMode('installing');
+                                }
+                                else {
+                                    setMode('scope');
+                                }
+                            }
+                            if (item.value === 'review')
+                                setMode('review');
+                        } }) })] }));
+    }
+    // Review unknown files
+    if (mode === 'review') {
+        const lowConf = classificationService.lowConfidence(classifications);
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: "Review unknown files" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: lowConf.map((c, i) => (_jsxs(Text, { color: theme.dim, children: [c.file, " \u2192 ", c.type, " (", c.confidence, "%) \u2014 ", c.reason] }, i))) }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [{ label: 'Continue without unknowns', value: 'continue' }], onSelect: () => {
+                            if (initialScope) {
+                                setScope(initialScope);
+                                setMode('installing');
+                            }
+                            else {
+                                setMode('scope');
+                            }
+                        } }) })] }));
+    }
+    return null;
+};
+export async function importCommand(args, options) {
+    const source = args[0];
+    let fromSource = options.from;
+    const useGithubDest = Boolean(options.githubDest || options.github);
+    const importAll = Boolean(options.all);
+    const skipConfirm = Boolean(options.yes || options.y);
+    const initialScope = options.project || options.p
+        ? 'project'
+        : options.global || options.g
+            ? 'global'
+            : undefined;
+    // Shorthand: `aman import cursor --global` → `aman import --from cursor --global`
+    const KNOWN_SOURCE_IDS = new Set([
+        'claude-code', 'cursor', 'windsurf', 'continue',
+        'vscode', 'github-copilot', 'codex',
+        'local-folder', 'custom-path', 'aman-environment',
+        'antigravity',
+    ]);
+    if (source && KNOWN_SOURCE_IDS.has(source) && !fromSource) {
+        fromSource = source;
+    }
+    // Interactive wizard when no source path and no --from
+    if (!source && !fromSource) {
+        if (!process.stdin.isTTY) {
+            console.error('\n  Error: Interactive import wizard requires a TTY.');
+            console.error('  Use: aman import <path> --global|--project');
+            console.error('  Or:  aman import claude-code --all --global\n');
+            process.exit(1);
+        }
+        const { waitUntilExit } = render(_jsx(ImportWizardApp, {}));
+        await waitUntilExit();
+        return;
+    }
+    // Adapter-based headless / flagged import
+    if (fromSource) {
+        if (!initialScope) {
+            console.error('Import requires --global or --project when using --from.');
+            process.exit(1);
+        }
+        if (useGithubDest && !isGithubDestinationAvailable()) {
+            console.error('\n  GitHub is not configured.');
+            console.error('  Run `aman init --github` or connect GitHub first.\n');
+            process.exit(1);
+        }
+        if (!environmentService.isEnvironmentInitialized(initialScope)) {
+            console.error('\n  Aman Intelligence is not initialized yet.');
+            console.error('  Run: aman init --local\n');
+            process.exit(1);
+        }
+        try {
+            // When using shorthand (aman import cursor ./path), the path is args[1]
+            // When using --from (aman import ./path --from cursor), the path is args[0]
+            const rootPath = (source && KNOWN_SOURCE_IDS.has(source)) ? args[1] : source;
+            console.log(`\n  ◌ Scanning ${fromSource}...`);
+            const discovered = await importDiscoveryService.scan(fromSource, rootPath ? { rootPath } : undefined);
+            if (discovered.length === 0) {
+                console.log('  No recognizable assets found. Nothing imported.');
+                return;
+            }
+            const items = importAll
+                ? discovered
+                : discovered.filter((d) => d.confidence >= 50 && d.canonicalStatus !== 'ambiguous');
+            if (items.length === 0) {
+                console.log('  No high-confidence assets to import. Use --all to include ambiguous items.');
+                return;
+            }
+            let conflicts = await detectImportConflicts(items, initialScope);
+            conflicts = applyAutoRenameConflicts(conflicts, skipConfirm ? 'suffix' : 'suffix');
+            const plan = {
+                sourceId: fromSource,
+                sourceLabel: fromSource,
+                destination: useGithubDest ? 'github' : 'local',
+                scope: initialScope,
+                items,
+                conflicts,
+            };
+            console.log(`  Found ${items.length} assets to import → ${initialScope}`);
+            const result = await executeImportPlan(plan);
+            console.log(`  ✓ Imported ${result.imported} (skipped ${result.skipped}, renamed ${result.renamed})\n`);
+        }
+        catch (err) {
+            console.error(`  ✗ Import failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+        return;
+    }
+    if (!source) {
+        console.log('  Usage: aman import [source] [options]');
+        console.log('  Examples:');
+        console.log('    aman import                              # interactive wizard (TTY)');
+        console.log('    aman import cursor --global              # shorthand: import from Cursor');
+        console.log('    aman import claude-code --all -g         # import all from Claude Code');
+        console.log('    aman import ./local-folder --global');
+        console.log('    aman import user/repo --global');
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        if (!initialScope) {
+            console.error('\n  \x1b[31;1mError: Interactive mode unavailable in non-TTY terminals.\x1b[0m');
+            console.error('  Please specify target scope using \x1b[33m--project\x1b[0m or \x1b[33m--global\x1b[0m.\n');
+            process.exit(1);
+        }
+        console.log(`\n  ◌ Cloning ${source}...`);
+        try {
+            const tempDir = await githubService.import(source);
+            console.log(`  ◌ Scanning ${source}...`);
+            const classifications = await classificationService.classifyDirectory(tempDir);
+            const highConf = classificationService.highConfidence(classifications);
+            if (highConf.length === 0) {
+                await removeDir(tempDir).catch(() => { });
+                console.log('  No recognizable assets found in source. Nothing imported.');
+                return;
+            }
+            console.log(`  Found ${highConf.length} high-confidence assets to import.`);
+            let installed = 0;
+            for (const c of highConf) {
+                let filePath = path.resolve(tempDir, c.file);
+                const safe = await isPathSafe(filePath, tempDir);
+                if (!safe) {
+                    throw new Error(`Security Exception: Path traversal escape attempt detected inside file: ${c.file}`);
+                }
+                let baseName = c.file.replace(/\.[^.]+$/, '').replace(/[/\\]/g, '-');
+                if (c.type === 'skill') {
+                    filePath = path.dirname(filePath);
+                    if (filePath === tempDir) {
+                        baseName = path.basename(source).replace(/\.git$/, '');
+                    }
+                    else {
+                        baseName = path.basename(filePath);
+                    }
+                }
+                if (c.type === 'skill' || c.type === 'prompt' || c.type === 'mcp') {
+                    const existingAssets = await assetService.list(c.type, initialScope);
+                    let name = baseName;
+                    let suffix = 1;
+                    while (existingAssets.some((item) => item.name === name)) {
+                        name = `${baseName}-${suffix}`;
+                        suffix++;
+                    }
+                    const metadataOverride = {};
+                    if (name !== baseName) {
+                        metadataOverride.originalName = baseName;
+                        metadataOverride.resolvedName = name;
+                    }
+                    await assetService.install(name, c.type, initialScope, filePath, source, metadataOverride);
+                    installed++;
+                }
+                await classificationService.remember(c.file, c.type);
+            }
+            await removeDir(tempDir).catch(() => { });
+            console.log(`  \x1b[32m✓ Imported ${installed} assets to ${initialScope} scope successfully.\x1b[0m\n`);
+        }
+        catch (err) {
+            console.error(`  \x1b[31m✗ Import failed: ${err.message}\x1b[0m\n`);
+            process.exit(1);
+        }
+        return;
+    }
+    const { waitUntilExit } = render(_jsx(TransitionScreen, { message: `Preparing to import ${source}...`, children: _jsx(ImportApp, { source: source, initialScope: initialScope }) }));
+    await waitUntilExit();
+}

package/dist/commands/info.d.ts

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

package/dist/commands/info.js

@@ -0,0 +1,174 @@
+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 { CustomSelectInput } from '../ui/components/CustomSelect.js';
+import { marketplaceService } from '../services/marketplace.service.js';
+import { assetService } from '../services/asset.service.js';
+import { ScopePrompt } from '../ui/components/ScopePrompt.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+import { metadataParts, titleize } from '../ui/marketplaceDisplay.js';
+import { assetTypeBadge, ASSET_TYPES } from '../ui/assetDisplay.js';
+import { assetListDescription, assetListOrganization, assetListTags, assetListVersion, } from '../utils/asset-list-fields.js';
+function normalizeLookupName(value) {
+    return value.toLowerCase().replace(/[\s_]+/g, '-');
+}
+async function findAssetByName(name) {
+    const normalized = normalizeLookupName(name);
+    for (const type of ASSET_TYPES) {
+        for (const scope of ['global', 'project']) {
+            const installed = await assetService.list(type, scope);
+            const match = installed.find((i) => normalizeLookupName(i.name) === normalized);
+            if (match) {
+                return {
+                    type,
+                    name: match.name,
+                    source: match.source || scope,
+                    description: assetListDescription(match),
+                    tags: assetListTags(match),
+                    version: assetListVersion(match),
+                    organization: assetListOrganization(match),
+                    installed: true,
+                    confidence: 1,
+                    slug: match.slug,
+                };
+            }
+        }
+    }
+    const marketplaceResults = await marketplaceService.search(name);
+    const exact = marketplaceResults.find((r) => normalizeLookupName(r.name) === normalized);
+    if (exact) {
+        for (const scope of ['global', 'project']) {
+            const installed = await assetService.list(exact.type, scope);
+            if (installed.some((i) => i.name === exact.name)) {
+                exact.installed = true;
+                break;
+            }
+        }
+        return exact;
+    }
+    const candidate = await marketplaceService.findInstallCandidate(name);
+    if (candidate) {
+        return {
+            type: candidate.type,
+            name: candidate.name,
+            source: candidate.source,
+            sources: candidate.sources,
+            description: candidate.description,
+            tags: candidate.tags,
+            category: candidate.category,
+            installs: candidate.installs,
+            rating: candidate.rating,
+            updated: candidate.updated,
+            version: candidate.version,
+            organization: candidate.organization,
+            installed: candidate.installed,
+            confidence: 1,
+        };
+    }
+    return null;
+}
+const InfoApp = ({ name }) => {
+    const { exit } = useApp();
+    const [item, setItem] = useState(null);
+    const [mode, setMode] = useState('loading');
+    const [mochiState, setMochiState] = useState('searching');
+    const [message, setMessage] = useState(`Looking up ${name}...`);
+    useInput((input) => {
+        if (input === 'q')
+            exit();
+    });
+    useEffect(() => {
+        async function lookup() {
+            const exact = await findAssetByName(name);
+            if (!exact) {
+                setMochiState('error');
+                setMessage(`Could not find asset "${name}" (skill, prompt, or MCP)`);
+                setMode('done');
+                setTimeout(() => exit(), 1500);
+                return;
+            }
+            setItem(exact);
+            setMode('detail');
+        }
+        lookup();
+    }, [exit, name]);
+    async function doInstall(scope) {
+        if (!item)
+            return;
+        setMode('installing');
+        setMochiState('installing');
+        setMessage(`Installing ${assetTypeBadge(item.type)} ${titleize(item.name)}...`);
+        try {
+            const candidate = await marketplaceService.findInstallCandidate(item.name);
+            if (candidate && candidate.type === item.type) {
+                await assetService.install(candidate.name, candidate.type, scope, candidate.sourcePath, candidate.source);
+            }
+            else {
+                await assetService.install(item.name, item.type, scope, undefined, item.source || 'local');
+            }
+            setMochiState('success');
+            setMessage(`Installed ${assetTypeBadge(item.type)} ${titleize(item.name)} → ${scope === 'project' ? 'project' : 'global'}`);
+        }
+        catch (err) {
+            setMochiState('error');
+            setMessage(`Error: ${err.message}`);
+        }
+        setMode('done');
+        setTimeout(() => exit(), 1000);
+    }
+    if (mode === 'loading') {
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsx(Narrator, { state: mochiState, message: message }) }));
+    }
+    if (mode === 'installing' || mode === 'done') {
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsx(Narrator, { state: mochiState, message: message }) }));
+    }
+    if (mode === 'scope' && item) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { bold: true, children: [assetTypeBadge(item.type), " ", titleize(item.name)] }), _jsx(Box, { marginTop: 1, children: _jsx(ScopePrompt, { onSelect: (s) => doInstall(s) }) })] }));
+    }
+    if (mode === 'detail' && item) {
+        const actions = item.installed
+            ? [{ label: 'Back', value: 'back' }]
+            : [
+                { label: 'Install', value: 'install' },
+                { label: 'Back', value: 'back' },
+            ];
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, children: [assetTypeBadge(item.type), " ", titleize(item.name)] }), item.installed && _jsx(Text, { color: theme.success, children: "installed" }), item.description && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.secondary, children: item.description }) })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [metadataParts(item).map((part, i) => (_jsx(Text, { color: theme.dim, children: part }, i))), item.tags && item.tags.length > 0 && _jsxs(Text, { color: theme.dim, children: ["Tags: ", item.tags.join(', ')] }), item.category && _jsxs(Text, { color: theme.dim, children: ["Category: ", item.category] }), item.organization && _jsxs(Text, { color: theme.dim, children: ["Author: ", item.organization] })] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: actions, onSelect: (a) => {
+                            if (a.value === 'install')
+                                setMode('scope');
+                            if (a.value === 'back')
+                                exit();
+                        } }) })] }));
+    }
+    return null;
+};
+export async function infoCommand(args) {
+    const name = args.join(' ');
+    if (!name) {
+        console.log('  Usage: aman info <name>');
+        console.log('  Works for skills, prompts, and MCPs (installed or registry catalog).');
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        const item = await findAssetByName(name);
+        if (!item) {
+            console.error(`  No asset found for "${name}".`);
+            process.exit(1);
+        }
+        console.log(`\n  ${assetTypeBadge(item.type)} ${titleize(item.name)}`);
+        if (item.description)
+            console.log(`  ${item.description}`);
+        for (const part of metadataParts(item)) {
+            console.log(`  ${part}`);
+        }
+        if (item.tags?.length)
+            console.log(`  Tags: ${item.tags.join(', ')}`);
+        if (item.installed)
+            console.log('  Status: installed');
+        console.log('');
+        return;
+    }
+    const { waitUntilExit } = render(_jsx(InfoApp, { name: name }));
+    await waitUntilExit();
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export type GithubMode = 'create' | 'existing';
+export type InitResult = {
+    action: 'local';
+} | {
+    action: 'github';
+    repository: string;
+    mode: GithubMode;
+} | {
+    action: 'exit';
+};
+export interface InitFlowProps {
+    startWithGithub?: boolean;
+    repository?: string;
+    githubMode?: GithubMode;
+    exitOnDone?: boolean;
+    onDone: (result: InitResult) => void;
+}
+export declare const InitFlow: React.FC<InitFlowProps>;
+export declare function initCommand(args: string[], options: any): Promise<void>;