aman-intelligence 0.1.0

package/dist/commands/search.js

@@ -0,0 +1,295 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { CustomSelectInput } from '../ui/components/CustomSelect.js';
+import TextInput from 'ink-text-input';
+import { marketplaceService } from '../services/marketplace.service.js';
+import { assetService } from '../services/asset.service.js';
+import { Header } from '../ui/components/Header.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { theme } from '../ui/theme.js';
+import { useResponsiveLayout, MIN_COLUMNS, MIN_ROWS } from '../ui/layout.js';
+import { TooSmallScreen } from '../ui/components/TooSmallScreen.js';
+import { metadataParts, titleize, verifiedBadge } from '../ui/marketplaceDisplay.js';
+import { installFromCandidate } from '../marketplace/install-from-candidate.js';
+import { MarketplaceInstallConfirm } from '../ui/components/MarketplaceInstallConfirm.js';
+import { PLAIN_OUTPUT_MAX_COLUMNS } from '../ui/layout.js';
+import { MARKETPLACE_ENABLED } from '../config/features.js';
+import { ASSET_TAB_ORDER, ASSET_TYPE_PLURAL, assetTypeBadge, groupResultsByType, matchesAssetSearch, } from '../ui/assetDisplay.js';
+import { TransitionScreen } from '../ui/animations/TransitionScreen.js';
+export const SearchApp = ({ onBack, initialQuery = '' }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const { rows, isTooSmall, isCompact, canShowDescriptions, physicalColumns, physicalRows } = useResponsiveLayout();
+    const pageSize = Math.max(1, rows - (canShowDescriptions ? 14 : 9));
+    const [query, setQuery] = useState(initialQuery);
+    const [results, setResults] = useState([]);
+    const [flatResults, setFlatResults] = useState([]);
+    const [cursor, setCursor] = useState(0);
+    const [mode, setMode] = useState(initialQuery ? 'results' : 'input');
+    const [mochiState, setMochiState] = useState('searching');
+    const [message, setMessage] = useState('Searching...');
+    const [loading, setLoading] = useState(Boolean(initialQuery));
+    const [filterQuery, setFilterQuery] = useState('');
+    const [filterActive, setFilterActive] = useState(false);
+    const [marketplaceNotice, setMarketplaceNotice] = useState();
+    const [installCandidate, setInstallCandidate] = useState(null);
+    async function performSearch(searchQuery) {
+        if (!searchQuery.trim())
+            return;
+        setLoading(true);
+        setCursor(0);
+        setMochiState('searching');
+        setMessage('Searching assets...');
+        try {
+            if (MARKETPLACE_ENABLED) {
+                const ghMeta = await marketplaceService.searchGitHubMarketplace(searchQuery);
+                if (ghMeta.message) {
+                    setMarketplaceNotice(ghMeta.fromCache && ghMeta.cacheAgeMinutes !== null
+                        ? `${ghMeta.message} Results from ${ghMeta.cacheAgeMinutes} minutes ago.`
+                        : ghMeta.message);
+                }
+                else if (ghMeta.fromCache && ghMeta.cacheAgeMinutes !== null) {
+                    setMarketplaceNotice(`Marketplace results from ${ghMeta.cacheAgeMinutes} minutes ago.`);
+                }
+                else {
+                    setMarketplaceNotice(undefined);
+                }
+            }
+            const found = await marketplaceService.search(searchQuery);
+            const installedByType = {
+                skill: new Set(),
+                prompt: new Set(),
+                mcp: new Set(),
+            };
+            for (const type of ASSET_TAB_ORDER) {
+                const global = await assetService.list(type, 'global');
+                const project = await assetService.list(type, 'project');
+                for (const item of [...global, ...project]) {
+                    installedByType[type].add(item.name);
+                }
+            }
+            const filtered = found.filter((r) => matchesAssetSearch(r, searchQuery));
+            for (const r of filtered) {
+                if (installedByType[r.type].has(r.name)) {
+                    r.installed = true;
+                }
+            }
+            const grouped = groupResultsByType(filtered);
+            const flat = [];
+            for (const type of ASSET_TAB_ORDER) {
+                flat.push(...grouped[type]);
+            }
+            setResults(filtered);
+            setFlatResults(flat);
+            setMode('results');
+        }
+        catch {
+            setResults([]);
+            setFlatResults([]);
+            setMode('results');
+        }
+        setLoading(false);
+    }
+    useEffect(() => {
+        if (initialQuery) {
+            performSearch(initialQuery);
+        }
+    }, [initialQuery]);
+    const displayResults = useMemo(() => {
+        const q = filterQuery.trim().toLowerCase();
+        if (!q)
+            return flatResults;
+        return flatResults.filter((r) => {
+            const hay = [r.name, r.slug, r.description, r.organization, ...(r.tags ?? [])]
+                .filter(Boolean)
+                .join(' ')
+                .toLowerCase();
+            return hay.includes(q);
+        });
+    }, [flatResults, filterQuery]);
+    const visibleItems = useMemo(() => {
+        const total = displayResults.length;
+        if (total === 0)
+            return [];
+        const half = Math.floor(pageSize / 2);
+        const start = Math.max(0, Math.min(cursor - half, Math.max(0, total - pageSize)));
+        return displayResults.slice(start, start + pageSize).map((item, idx) => ({
+            item,
+            index: start + idx,
+        }));
+    }, [cursor, displayResults, pageSize]);
+    const focusedItem = displayResults[cursor];
+    useInput((input, key) => {
+        if (input === 'q') {
+            handleExit();
+            return;
+        }
+        if (mode === 'input') {
+            if (key.escape)
+                handleExit();
+            return;
+        }
+        if (mode === 'results') {
+            if (input === '/') {
+                setFilterActive(true);
+                setFilterQuery('');
+                setCursor(0);
+                return;
+            }
+            if (filterActive && input.length === 1 && !key.ctrl && !key.meta) {
+                setFilterQuery((prev) => prev + input);
+                setCursor(0);
+                return;
+            }
+            if (key.escape || key.backspace || key.delete) {
+                if (filterActive || filterQuery) {
+                    setFilterQuery('');
+                    setFilterActive(false);
+                    setCursor(0);
+                }
+                else {
+                    setMode('input');
+                }
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setCursor((p) => Math.max(0, p - 1));
+                return;
+            }
+            if (key.downArrow || input === 'j') {
+                setCursor((p) => Math.min(displayResults.length - 1, p + 1));
+                return;
+            }
+            if (key.return && focusedItem) {
+                setMode('detail');
+                return;
+            }
+        }
+        if (mode === 'detail') {
+            if (key.escape || input === 'b') {
+                setMode('results');
+                return;
+            }
+        }
+    });
+    async function prepareInstall() {
+        if (!focusedItem)
+            return;
+        const candidate = await marketplaceService.findInstallCandidate(focusedItem.slug ?? focusedItem.name);
+        if (!candidate) {
+            setMochiState('error');
+            setMessage('Asset not found');
+            setMode('done');
+            return;
+        }
+        setInstallCandidate(candidate);
+        setMode('confirm');
+    }
+    async function doInstall(scope) {
+        if (!installCandidate)
+            return;
+        setMode('installing');
+        setMochiState('installing');
+        setMessage(`Installing ${titleize(installCandidate.name)}...`);
+        try {
+            const result = await installFromCandidate(installCandidate, scope);
+            setMochiState('success');
+            setMessage(`Installed ${assetTypeBadge(installCandidate.type)} ${titleize(installCandidate.name)} → ${result.path}`);
+        }
+        catch (err) {
+            setMochiState('error');
+            setMessage(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        setMode('done');
+        setTimeout(() => handleExit(), 1200);
+    }
+    if (isTooSmall) {
+        return (_jsx(TooSmallScreen, { columns: physicalColumns, rows: physicalRows, minColumns: MIN_COLUMNS, minRows: MIN_ROWS }));
+    }
+    if (mode === 'input') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, color: theme.accent, children: "Search Assets" }), _jsx(Text, { color: theme.dim, children: "Search skills, prompts, and MCPs by name, description, or tags" }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { color: theme.primary, children: "\u276F " }), _jsx(TextInput, { value: query, onChange: setQuery, onSubmit: (val) => performSearch(val), placeholder: "Type search query... (e.g. react, github)" })] })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press enter to search \u00B7 esc go back" }) })] }));
+    }
+    if (loading) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: "searching", message: "Searching..." })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "Please wait..." }) })] }));
+    }
+    if (mode === 'installing' || mode === 'done') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: [_jsx(Box, { flexDirection: "column", children: _jsx(Narrator, { state: mochiState, message: message }) }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "Please wait..." }) })] }));
+    }
+    if (mode === 'confirm' && installCandidate) {
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: _jsx(MarketplaceInstallConfirm, { details: {
+                    name: installCandidate.name,
+                    type: installCandidate.type,
+                    slug: installCandidate.slug,
+                    author: installCandidate.organization,
+                    version: installCandidate.version,
+                    source: installCandidate.githubSource ?? installCandidate.source,
+                    checksum: installCandidate.checksum,
+                    verified: installCandidate.verified,
+                }, onConfirm: (s) => doInstall(s), onCancel: () => setMode('detail') }) }));
+    }
+    if (mode === 'detail' && focusedItem) {
+        const detailActions = [
+            { label: 'Install', value: 'install' },
+            { label: 'Back', value: 'back' },
+        ];
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, children: [assetTypeBadge(focusedItem.type), " ", titleize(focusedItem.name)] }), focusedItem.description && (_jsx(Text, { color: theme.secondary, children: focusedItem.description })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [metadataParts(focusedItem).map((part, i) => (_jsx(Text, { color: theme.dim, children: part }, i))), focusedItem.tags && focusedItem.tags.length > 0 && (_jsxs(Text, { color: theme.dim, children: ["Tags: ", focusedItem.tags.join(', ')] })), focusedItem.installed && _jsx(Text, { color: theme.success, children: "installed" })] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: detailActions, onSelect: (item) => {
+                                    if (item.value === 'install')
+                                        void prepareInstall();
+                                    if (item.value === 'back')
+                                        setMode('results');
+                                } }) })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press enter to select \u00B7 esc go back" }) })] }));
+    }
+    const localResults = results.filter((r) => r.section !== 'marketplace');
+    const marketplaceResults = results.filter((r) => r.section === 'marketplace');
+    const grouped = groupResultsByType(displayResults);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { compact: true }), marketplaceNotice && (_jsx(Text, { color: theme.warning, wrap: "truncate", children: marketplaceNotice })), _jsxs(Text, { color: theme.dim, children: [displayResults.length, " result", displayResults.length !== 1 ? 's' : '', " \u00B7 Local", ' ', localResults.length, MARKETPLACE_ENABLED ? ` · Marketplace ${marketplaceResults.length}` : ''] }), !filterActive && filterQuery === '' && (_jsx(Box, { marginTop: 0, children: _jsx(Text, { color: theme.dim, children: "/ filter \u00B7 j/k navigate \u00B7 enter details \u00B7 q quit" }) })), (filterActive || filterQuery !== '') && (_jsxs(Box, { flexDirection: "row", marginTop: 0, children: [_jsx(Text, { color: theme.primary, children: "/ " }), _jsx(TextInput, { value: filterQuery, onChange: (v) => {
+                                    setFilterQuery(v);
+                                    setCursor(0);
+                                }, placeholder: "filter..." })] })), _jsx(Text, { children: ' ' }), _jsx(Box, { flexDirection: "column", height: pageSize, children: visibleItems.length === 0 ? (_jsx(Text, { color: theme.dim, children: "No results found." })) : (visibleItems.map(({ item, index }) => {
+                            const isCurrent = index === cursor;
+                            const isInstalled = item.installed;
+                            const showSectionHeader = index === 0 || displayResults[index - 1]?.section !== item.section;
+                            const showTypeHeader = showSectionHeader ||
+                                displayResults[index - 1]?.type !== item.type;
+                            return (_jsxs(Box, { flexDirection: "column", children: [showSectionHeader && (_jsx(Text, { color: theme.accent, bold: true, children: item.section === 'marketplace' ? 'Marketplace' : 'Local' })), showTypeHeader && (_jsx(Text, { color: theme.secondary, children: ASSET_TYPE_PLURAL[item.type] })), _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: isCurrent ? theme.primary : theme.dim, children: isCurrent ? ' › ' : '   ' }), _jsx(Text, { color: isCurrent ? theme.text : theme.secondary, children: isInstalled ? '● ' : '○ ' }), _jsxs(Text, { color: theme.dim, children: [assetTypeBadge(item.type), " "] }), _jsxs(Text, { color: isCurrent ? theme.text : theme.secondary, bold: isCurrent, children: [item.slug ?? titleize(item.name), verifiedBadge(item.verified)] }), item.stars !== undefined && !isCompact && (_jsxs(Text, { color: theme.dim, children: [" \u2605", item.stars] })), isInstalled && _jsx(Text, { color: theme.dim, children: " installed" })] })] }, `${item.section}:${item.type}:${item.name}`));
+                        })) })] }), _jsxs(Box, { flexDirection: "column", children: [canShowDescriptions && (_jsx(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, borderStyle: "round", borderColor: theme.borderMuted, height: isCompact ? 0 : 5, justifyContent: "center", children: _jsx(Text, { color: theme.text, children: displayResults[cursor]?.description || '' }) })), _jsx(Box, { marginTop: isCompact ? 1 : 0, children: _jsx(Text, { color: theme.dim, children: isCompact
+                                ? '↑↓ navigate  enter details  esc search again'
+                                : '↑↓ navigate  enter details  esc search again  q quit' }) })] })] }));
+};
+export async function searchCommand(args, options = {}) {
+    const query = args.join(' ');
+    const forcePlain = options.noTty === true;
+    const columns = process.stdout.columns ?? 80;
+    const plain = forcePlain || !process.stdin.isTTY || !process.stdout.isTTY || columns <= PLAIN_OUTPUT_MAX_COLUMNS;
+    if (plain) {
+        if (MARKETPLACE_ENABLED) {
+            const ghMeta = await marketplaceService.searchGitHubMarketplace(query);
+            if (ghMeta.message) {
+                console.error(ghMeta.message);
+            }
+        }
+        const results = (await marketplaceService.search(query)).filter((r) => matchesAssetSearch(r, query));
+        for (const r of results) {
+            const label = r.section === 'marketplace' ? 'marketplace' : 'registry';
+            const badge = r.verified ? ' ✓' : '';
+            console.log(`${r.type}  ${r.slug ?? r.name}  ${r.version ?? '-'}  ${r.description ?? ''}${badge}  [${label}]`);
+        }
+        if (results.length === 0)
+            console.log('No results found.');
+        return;
+    }
+    if (query.trim()) {
+        const { waitUntilExit } = render(_jsx(TransitionScreen, { message: `Searching assets for "${query}"...`, children: _jsx(SearchApp, { initialQuery: query }) }));
+        await waitUntilExit();
+    }
+    else {
+        const { waitUntilExit } = render(_jsx(SearchApp, { initialQuery: "" }));
+        await waitUntilExit();
+    }
+}

package/dist/commands/stack.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Scope } from '../types/index.js';
+interface StackCreateAppProps {
+    name: string;
+    scope: Scope;
+}
+export declare const StackCreateApp: React.FC<StackCreateAppProps & {
+    onBack?: () => void;
+}>;
+interface StackActivateAppProps {
+    name: string;
+    scope: Scope;
+}
+export declare const StackActivateApp: React.FC<StackActivateAppProps & {
+    onBack?: () => void;
+}>;
+export declare function stackCommand(args: string[], options: any): Promise<void>;
+export {};

package/dist/commands/stack.js

@@ -0,0 +1,327 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState, useRef } from 'react';
+import { render, Box, Text, useApp, useInput } from 'ink';
+import { stackService } from '../services/stack.service.js';
+import { assetService } from '../services/asset.service.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+import { titleize } from '../ui/marketplaceDisplay.js';
+import { scanAll } from '../storage/scanner.js';
+import { environmentService } from '../services/environment.service.js';
+import { exists } from '../storage/filesystem.js';
+import { ASSET_TAB_ORDER, ASSET_TYPE_PLURAL, assetCompositeKey, parseAssetCompositeKey, } from '../ui/assetDisplay.js';
+const PAGE_SIZE = 8;
+async function installStackMembers(stack, stackName) {
+    let installed = 0;
+    let skills = 0;
+    let prompts = 0;
+    let mcps = 0;
+    const members = [
+        ...stack.skills.map((name) => ({ name, type: 'skill' })),
+        ...stack.prompts.map((name) => ({ name, type: 'prompt' })),
+        ...stack.mcps.map((name) => ({ name, type: 'mcp' })),
+    ];
+    for (const { name, type } of members) {
+        try {
+            await assetService.install(name, type, 'project', undefined, `stack:${stackName}`);
+            installed++;
+            if (type === 'skill')
+                skills++;
+            if (type === 'prompt')
+                prompts++;
+            if (type === 'mcp')
+                mcps++;
+        }
+        catch {
+            // Already installed or not found
+        }
+    }
+    return { installed, skills, prompts, mcps };
+}
+function activationSummary(counts) {
+    const parts = [];
+    if (counts.skills > 0)
+        parts.push(`${counts.skills} skill${counts.skills !== 1 ? 's' : ''}`);
+    if (counts.prompts > 0)
+        parts.push(`${counts.prompts} prompt${counts.prompts !== 1 ? 's' : ''}`);
+    if (counts.mcps > 0)
+        parts.push(`${counts.mcps} MCP${counts.mcps !== 1 ? 's' : ''}`);
+    return parts.length > 0 ? parts.join(', ') : '0 assets';
+}
+export const StackCreateApp = ({ name, scope, onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const [category, setCategory] = useState(ASSET_TAB_ORDER[0]);
+    const [allItems, setAllItems] = useState([]);
+    const [cursor, setCursor] = useState(0);
+    const [selected, setSelected] = useState(new Set());
+    const [done, setDone] = useState(false);
+    const [state, setState] = useState('idle');
+    const [message, setMessage] = useState('');
+    const [loading, setLoading] = useState(true);
+    useEffect(() => {
+        async function load() {
+            const globalDir = environmentService.getActiveEnvironmentDir();
+            const projectDir = environmentService.getProjectEnvironmentDir();
+            const globalData = await scanAll(globalDir, 'global');
+            let projectData = {
+                skills: [],
+                prompts: [],
+                mcps: [],
+            };
+            if (exists(projectDir)) {
+                projectData = await scanAll(projectDir, 'project');
+            }
+            function mergeAssets(items, type) {
+                const merged = new Map();
+                const seen = new Set();
+                for (const item of items) {
+                    const baseName = (item.originalName || item.name)
+                        .replace(/[-_\s]+\d+$/, '')
+                        .toLowerCase()
+                        .replace(/[-_\s]+/g, ' ')
+                        .trim();
+                    if (seen.has(baseName))
+                        continue;
+                    seen.add(baseName);
+                    merged.set(item.name, { name: item.name, label: titleize(baseName), type });
+                }
+                return Array.from(merged.values());
+            }
+            setAllItems([
+                ...mergeAssets([...globalData.skills, ...projectData.skills], 'skill'),
+                ...mergeAssets([...globalData.prompts, ...projectData.prompts], 'prompt'),
+                ...mergeAssets([...globalData.mcps, ...projectData.mcps], 'mcp'),
+            ]);
+            setLoading(false);
+        }
+        load();
+    }, []);
+    const items = useMemo(() => allItems.filter((i) => i.type === category), [allItems, category]);
+    const visibleItems = useMemo(() => {
+        if (items.length === 0)
+            return [];
+        const half = Math.floor(PAGE_SIZE / 2);
+        const start = Math.max(0, Math.min(cursor - half, Math.max(0, items.length - PAGE_SIZE)));
+        return items.slice(start, start + PAGE_SIZE).map((item, idx) => ({
+            item,
+            index: start + idx,
+        }));
+    }, [cursor, items]);
+    useInput((input, key) => {
+        if (input === 'q' || key.escape) {
+            handleExit();
+            return;
+        }
+        if (done)
+            return;
+        if (key.leftArrow || key.rightArrow) {
+            setCategory((prev) => {
+                const idx = ASSET_TAB_ORDER.indexOf(prev);
+                const next = key.leftArrow
+                    ? (idx - 1 + ASSET_TAB_ORDER.length) % ASSET_TAB_ORDER.length
+                    : (idx + 1) % ASSET_TAB_ORDER.length;
+                return ASSET_TAB_ORDER[next];
+            });
+            setCursor(0);
+            return;
+        }
+        if (key.upArrow) {
+            setCursor((p) => Math.max(0, p - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor((p) => Math.min(items.length - 1, p + 1));
+            return;
+        }
+        if (input === ' ') {
+            const item = items[cursor];
+            if (!item)
+                return;
+            const keyId = assetCompositeKey(item.type, item.name);
+            setSelected((prev) => {
+                const next = new Set(prev);
+                if (next.has(keyId))
+                    next.delete(keyId);
+                else
+                    next.add(keyId);
+                return next;
+            });
+            return;
+        }
+        if (key.return && selected.size > 0) {
+            createStack();
+        }
+    });
+    async function createStack() {
+        setDone(true);
+        setState('installing');
+        setMessage(`Creating stack: ${name}...`);
+        try {
+            const skills = [];
+            const prompts = [];
+            const mcps = [];
+            for (const keyId of selected) {
+                const parsed = parseAssetCompositeKey(keyId);
+                if (!parsed)
+                    continue;
+                if (parsed.type === 'skill')
+                    skills.push(parsed.localName);
+                if (parsed.type === 'prompt')
+                    prompts.push(parsed.localName);
+                if (parsed.type === 'mcp')
+                    mcps.push(parsed.localName);
+            }
+            await stackService.create(scope, name, skills, prompts, mcps, `Stack: ${name}`);
+            setState('success');
+            setMessage(`Created stack: ${name} (${skills.length} skills, ${prompts.length} prompts, ${mcps.length} MCPs)`);
+        }
+        catch (err) {
+            setState('error');
+            setMessage(`Error: ${err.message}`);
+        }
+        setTimeout(() => handleExit(), 1000);
+    }
+    if (loading) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: "searching", message: "Loading assets..." })] }));
+    }
+    if (done) {
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsx(Narrator, { state: state, message: message }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { children: ["Select assets for ", _jsx(Text, { bold: true, children: name }), " stack"] }), _jsx(Box, { marginY: 1, children: ASSET_TAB_ORDER.map((t) => (_jsx(Box, { marginRight: 2, children: _jsxs(Text, { color: category === t ? theme.primary : theme.dim, bold: category === t, children: [category === t ? '❯ ' : '  ', ASSET_TYPE_PLURAL[t]] }) }, t))) }), items.length === 0 ? (_jsxs(Text, { color: theme.dim, children: ["No installed ", ASSET_TYPE_PLURAL[category].toLowerCase(), " in this environment."] })) : (visibleItems.map(({ item, index }) => {
+                const isCurrent = index === cursor;
+                const isSelected = selected.has(assetCompositeKey(item.type, item.name));
+                return (_jsxs(Text, { children: [_jsx(Text, { color: isCurrent ? theme.primary : theme.dim, children: isCurrent ? ' › ' : '   ' }), _jsx(Text, { color: isSelected ? theme.primary : theme.secondary, children: isSelected ? '◆ ' : '○ ' }), _jsx(Text, { color: isCurrent ? theme.text : theme.secondary, bold: isCurrent, children: item.label })] }, assetCompositeKey(item.type, item.name)));
+            })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.dim, children: ["\u2190\u2192 type \u00B7 space select \u00B7 enter create \u00B7 q quit", selected.size > 0 ? ` · ${selected.size} selected` : ''] }) })] }));
+};
+export const StackActivateApp = ({ name, scope, onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const [state, setState] = useState('installing');
+    const [message, setMessage] = useState(`Activating ${name}...`);
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            handleExit();
+        }
+    });
+    const started = useRef(false);
+    useEffect(() => {
+        if (started.current)
+            return;
+        started.current = true;
+        async function activate() {
+            try {
+                const stacks = await stackService.list(scope);
+                const stack = stacks.find((s) => s.name === name);
+                if (!stack) {
+                    setState('error');
+                    setMessage(`Stack "${name}" not found`);
+                    setTimeout(() => handleExit(), 1200);
+                    return;
+                }
+                const counts = await installStackMembers(stack, name);
+                setState('success');
+                setMessage(`Activated ${name} → ${activationSummary(counts)} loaded into project`);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(`Error: ${err.message}`);
+            }
+            setTimeout(() => handleExit(), 1000);
+        }
+        activate();
+    }, [name, scope]);
+    return (_jsx(Box, { paddingX: 1, children: _jsx(Narrator, { state: state, message: message }) }));
+};
+async function listStacks(scope) {
+    const stacks = await stackService.list(scope);
+    if (stacks.length === 0) {
+        console.log(`  No stacks in ${scope}.`);
+        return;
+    }
+    for (const s of stacks) {
+        const parts = [];
+        if (s.skills.length > 0)
+            parts.push(`${s.skills.length} skills`);
+        if (s.prompts.length > 0)
+            parts.push(`${s.prompts.length} prompts`);
+        if (s.mcps.length > 0)
+            parts.push(`${s.mcps.length} mcps`);
+        console.log(`  ${s.name}${parts.length > 0 ? `  ${parts.join(', ')}` : ''}`);
+    }
+}
+export async function stackCommand(args, options) {
+    const subcmd = args[0];
+    const scope = options.project || options.p ? 'project' : 'global';
+    if (subcmd === 'create') {
+        const name = args[1];
+        if (!name) {
+            console.log('  Usage: aman stack create <name>');
+            return;
+        }
+        if (!process.stdin.isTTY) {
+            console.log('  ERROR: Stack creation requires an interactive TTY terminal.');
+            process.exit(1);
+        }
+        const { waitUntilExit } = render(_jsx(StackCreateApp, { name: name, scope: scope }));
+        await waitUntilExit();
+    }
+    else if (subcmd === 'activate') {
+        const name = args[1];
+        if (!name) {
+            console.log('  Usage: aman stack activate <name>');
+            return;
+        }
+        if (!process.stdin.isTTY) {
+            console.log(`  ◌ Activating stack ${name} → project...`);
+            try {
+                const stacks = await stackService.list(scope);
+                const stack = stacks.find((s) => s.name === name);
+                if (!stack) {
+                    console.log(`  ✗ Error: Stack "${name}" not found`);
+                    process.exit(1);
+                }
+                const counts = await installStackMembers(stack, name);
+                console.log(`  ✓ Activated ${name} → ${activationSummary(counts)} loaded into project`);
+            }
+            catch (err) {
+                console.log(`  ✗ Activation error: ${err.message}`);
+                process.exit(1);
+            }
+            return;
+        }
+        const { waitUntilExit } = render(_jsx(StackActivateApp, { name: name, scope: scope }));
+        await waitUntilExit();
+    }
+    else if (subcmd === 'list') {
+        await listStacks(scope);
+    }
+    else if (subcmd === 'remove') {
+        const name = args[1];
+        if (!name) {
+            console.log('  Usage: aman stack remove <name>');
+            return;
+        }
+        try {
+            await stackService.remove(scope, name);
+            console.log(`  ✓ Stack ${name} removed`);
+        }
+        catch (err) {
+            console.error(`  ✗ Error: ${err.message}`);
+        }
+    }
+    else {
+        console.log('  Usage: aman stack <create|activate|list|remove> [name]');
+    }
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface SyncAppProps {
+    action: 'push' | 'pull';
+}
+export declare const SyncApp: React.FC<SyncAppProps & {
+    onBack?: () => void;
+}>;
+export declare function syncCommand(args: string[]): Promise<void>;
+export {};