aman-intelligence 0.1.0

package/dist/commands/pack.js

@@ -0,0 +1,331 @@
+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 { packService } from '../services/pack.service.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { ScopePrompt } from '../ui/components/ScopePrompt.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+import { titleize } from '../ui/marketplaceDisplay.js';
+import { ASSET_TYPE_PLURAL, ASSET_TAB_ORDER, assetCompositeKey, parseAssetCompositeKey } from '../ui/assetDisplay.js';
+import { scanAll } from '../storage/scanner.js';
+import { environmentService } from '../services/environment.service.js';
+import path from 'path';
+import { exists } from '../storage/filesystem.js';
+import { ProgressBar } from '../ui/animations/ProgressBar.js';
+import { TransitionScreen } from '../ui/animations/TransitionScreen.js';
+const PAGE_SIZE = 8;
+export const PackCreateApp = ({ name, 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 [mode, setMode] = useState('select');
+    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 (mode !== 'select')
+            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 composite = assetCompositeKey(item.type, item.name);
+            setSelected((prev) => {
+                const next = new Set(prev);
+                if (next.has(composite))
+                    next.delete(composite);
+                else
+                    next.add(composite);
+                return next;
+            });
+            return;
+        }
+        if (key.return && selected.size > 0) {
+            createPack();
+        }
+    });
+    async function createPack() {
+        setMode('creating');
+        setState('installing');
+        setMessage(`Creating ${name}.amanpack...`);
+        try {
+            const selectedByType = (type) => Array.from(selected)
+                .map((key) => parseAssetCompositeKey(key))
+                .filter((p) => p !== null && p.type === type)
+                .map((p) => p.localName);
+            const packDef = {
+                name,
+                version: '1.0.0',
+                description: `Workflow pack: ${name}`,
+                skills: selectedByType('skill'),
+                prompts: selectedByType('prompt'),
+                mcps: selectedByType('mcp'),
+                stacks: [],
+                createdAt: new Date().toISOString(),
+            };
+            const outPath = path.resolve(process.cwd(), `${name}.amanpack`);
+            await packService.create(name, packDef, outPath);
+            setState('success');
+            setMessage(`Created ${name}.amanpack (${packDef.skills.length} skills, ${packDef.prompts.length} prompts, ${packDef.mcps.length} MCPs)`);
+        }
+        catch (err) {
+            setState('error');
+            setMessage(`Error: ${err.message}`);
+        }
+        setMode('done');
+        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 (mode === 'creating' || mode === '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 })] }), _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))) }), 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 })] }, item.name));
+            }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.dim, children: ["\u2190\u2192 category  space select  enter create  q quit", selected.size > 0 ? `  · ${selected.size} selected` : ''] }) })] }));
+};
+export const PackInspectApp = ({ packPath, onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const [manifest, setManifest] = useState(null);
+    const [error, setError] = useState(null);
+    const started = useRef(false);
+    useEffect(() => {
+        if (started.current)
+            return;
+        started.current = true;
+        async function inspect() {
+            try {
+                const m = await packService.inspect(packPath);
+                setManifest(m);
+            }
+            catch (err) {
+                setError(err.message);
+            }
+            setTimeout(() => handleExit(), 300);
+        }
+        inspect();
+    }, [packPath]);
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            handleExit();
+        }
+    });
+    if (error) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Narrator, { state: "error", message: error }) }));
+    }
+    if (!manifest) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Narrator, { state: "searching", message: "Inspecting..." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: titleize(manifest.name) }), manifest.version && _jsxs(Text, { color: theme.dim, children: ["v", manifest.version] }), manifest.description && _jsx(Text, { color: theme.secondary, children: manifest.description }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.dim, children: ["Skills: ", manifest.skills.length] }), _jsxs(Text, { color: theme.dim, children: ["Prompts: ", manifest.prompts.length] }), _jsxs(Text, { color: theme.dim, children: ["MCPs: ", manifest.mcps.length] }), _jsxs(Text, { color: theme.dim, children: ["Stacks: ", manifest.stacks.length] })] }), manifest.skills.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.primary, children: "Skills" }), manifest.skills.map((s) => (_jsxs(Text, { color: theme.dim, children: ['  ', "\u2713 ", titleize(s)] }, s)))] })), manifest.prompts.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.primary, children: "Prompts" }), manifest.prompts.map((p) => (_jsxs(Text, { color: theme.dim, children: ['  ', "\u2713 ", titleize(p)] }, p)))] })), manifest.mcps.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.primary, children: "MCPs" }), manifest.mcps.map((m) => (_jsxs(Text, { color: theme.dim, children: ['  ', "\u2713 ", titleize(m)] }, m)))] }))] }));
+};
+export const PackInstallApp = ({ packPath, initialScope, onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const [scope, setScope] = useState(initialScope);
+    const [state, setState] = useState('idle');
+    const [message, setMessage] = useState('');
+    const [progress, setProgress] = useState(0);
+    const started = useRef(false);
+    useEffect(() => {
+        if (!scope)
+            return;
+        if (started.current)
+            return;
+        started.current = true;
+        async function install() {
+            setState('installing');
+            setMessage(`Installing pack...`);
+            try {
+                await packService.install(packPath, scope, (p) => setProgress(p));
+                setState('success');
+                setMessage(`Installed pack → ${scope === 'project' ? 'project' : 'global'}`);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(`Error: ${err.message}`);
+            }
+            setTimeout(() => handleExit(), 1000);
+        }
+        install();
+    }, [packPath, scope]);
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            handleExit();
+        }
+    });
+    if (!scope) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(ScopePrompt, { onSelect: (s) => setScope(s) })] }));
+    }
+    return (_jsxs(Box, { paddingX: 1, flexDirection: "column", children: [_jsx(Narrator, { state: state, message: message }), state === 'installing' && (_jsx(Box, { marginTop: 1, children: _jsx(ProgressBar, { progress: progress }) }))] }));
+};
+// ── Entry point ─────────────────────────────────────────────────────
+export async function packCommand(args, options) {
+    const subcmd = args[0];
+    if (subcmd === 'create') {
+        const name = args[1];
+        if (!name) {
+            console.log('  Usage: aman pack create <name>');
+            return;
+        }
+        if (!process.stdin.isTTY) {
+            console.log('  ERROR: Selective pack creation requires an interactive TTY terminal.');
+            process.exit(1);
+        }
+        const { waitUntilExit } = render(_jsx(PackCreateApp, { name: name }));
+        await waitUntilExit();
+    }
+    else if (subcmd === 'inspect') {
+        const packPath = args[1];
+        if (!packPath) {
+            console.log('  Usage: aman pack inspect <file.amanpack>');
+            return;
+        }
+        if (!process.stdin.isTTY) {
+            console.log('  ◌ Inspecting...');
+            try {
+                const manifest = await packService.inspect(packPath);
+                console.log(`  ${titleize(manifest.name)}`);
+                console.log(`  v${manifest.version || '1.0.0'}`);
+                console.log(`  ${manifest.description || ''}\n`);
+                console.log(`  Skills: ${manifest.skills.length}`);
+                console.log(`  Prompts: ${manifest.prompts.length}`);
+                console.log(`  MCPs: ${manifest.mcps.length}`);
+                console.log(`  Stacks: ${manifest.stacks.length}\n`);
+                console.log('  Contents:');
+                manifest.skills.forEach((s) => console.log(`    ${titleize(s)}`));
+            }
+            catch (err) {
+                console.log(`  ✗ Inspect error: ${err.message}`);
+                process.exit(1);
+            }
+            return;
+        }
+        const { waitUntilExit } = render(_jsx(PackInspectApp, { packPath: packPath }));
+        await waitUntilExit();
+    }
+    else if (subcmd === 'install') {
+        const packPath = args[1];
+        if (!packPath) {
+            console.log('  Usage: aman pack install <file.amanpack>');
+            return;
+        }
+        let scope = options.project || options.p
+            ? 'project'
+            : options.global || options.g
+                ? 'global'
+                : undefined;
+        if (!process.stdin.isTTY && !scope) {
+            console.error('Pack install requires --global or --project when not interactive.\n' +
+                'Example: aman pack install ./bundle.amanpack --global');
+            process.exit(1);
+        }
+        if (!process.stdin.isTTY) {
+            console.log(`  ◌ Installing pack ${packPath} → ${scope}...`);
+            try {
+                await packService.install(packPath, scope);
+                console.log(`  ✓ Installed pack → ${scope}`);
+            }
+            catch (err) {
+                console.log(`  ✗ Install error: ${err.message}`);
+                process.exit(1);
+            }
+            return;
+        }
+        const { waitUntilExit } = render(_jsx(TransitionScreen, { message: `Preparing pack installation for ${path.basename(packPath)}...`, children: _jsx(PackInstallApp, { packPath: packPath, initialScope: scope }) }));
+        await waitUntilExit();
+    }
+    else {
+        console.log('  Usage: aman pack <create|inspect|install> [args]');
+    }
+}

package/dist/commands/registry.d.ts

@@ -0,0 +1,6 @@
+import { AssetType } from '../types/index.js';
+export declare function registryCommand(args: string[], options: {
+    github?: boolean;
+}): Promise<void>;
+/** Publish from an installed global asset path (convenience for bootstrapping). */
+export declare function publishInstalledAsset(localName: string, type: AssetType, slug: string, version: string): Promise<void>;

package/dist/commands/registry.js

@@ -0,0 +1,218 @@
+import path from 'path';
+import { registryService } from '../registry/registry.service.js';
+import { RegistryError } from '../registry/errors.js';
+import { parseRegistryReference } from '../registry/slug-utils.js';
+import { assetDir, isCanonicalAssetDir } from '../storage/asset-layout.js';
+import { exists } from '../storage/filesystem.js';
+import { environmentService } from '../services/environment.service.js';
+import { localNameFromSlug } from '../utils/slug.js';
+function printRegistryError(err) {
+    if (err instanceof RegistryError) {
+        console.error(`Registry error [${err.code}]: ${err.message}`);
+        return;
+    }
+    console.error(err);
+}
+export async function registryCommand(args, options) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    if (options.github) {
+        registryService.setBackend('github');
+    }
+    switch (sub) {
+        case 'publish':
+            await publishSubcommand(rest);
+            break;
+        case 'deprecate':
+            await deprecateSubcommand(rest);
+            break;
+        case 'list':
+            await listSubcommand(rest);
+            break;
+        case 'search':
+            await searchSubcommand(rest.join(' '));
+            break;
+        case 'resolve':
+            await resolveSubcommand(rest);
+            break;
+        default:
+            console.log(`Usage: aman registry <command>
+
+Commands:
+  publish   Publish a canonical asset directory to the registry
+  deprecate Mark a published version deprecated
+  list      List published versions for a slug
+  search    Search the registry index
+  resolve   Resolve slug@version metadata
+
+Examples:
+  aman registry publish ./skills/caveman --slug @aman/caveman --version 1.0.0 --type skill
+  aman registry deprecate @aman/caveman@1.0.0 --reason "Superseded" --successor @aman/caveman@1.0.1
+  aman registry list @aman/caveman
+  aman registry search react
+  aman install @aman/caveman@1.0.0 --global
+`);
+    }
+}
+async function publishSubcommand(args) {
+    const contentArg = args[0];
+    if (!contentArg) {
+        console.error('Usage: aman registry publish <content-dir> --slug @scope/name --version X.Y.Z --type skill|prompt|mcp');
+        process.exit(1);
+    }
+    let slug = '';
+    let version = '';
+    let type = 'skill';
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--slug' && args[i + 1])
+            slug = args[++i];
+        else if (args[i] === '--version' && args[i + 1])
+            version = args[++i];
+        else if (args[i] === '--type' && args[i + 1])
+            type = args[++i];
+    }
+    if (!slug || !version) {
+        console.error('Required: --slug @scope/name --version X.Y.Z');
+        process.exit(1);
+    }
+    const contentDirectory = path.resolve(contentArg);
+    if (!exists(contentDirectory) || !isCanonicalAssetDir(type, contentDirectory)) {
+        console.error(`Not a canonical ${type} directory: ${contentDirectory}`);
+        process.exit(1);
+    }
+    const name = localNameFromSlug(slug);
+    const id = registryService.newPublishId();
+    try {
+        const result = await registryService.publish({
+            slug,
+            version,
+            type,
+            contentDirectory,
+            metadata: {
+                id,
+                slug,
+                type,
+                name,
+                description: '',
+                version,
+                author: 'local',
+                tags: [],
+                visibility: 'public',
+                dependencies: [],
+            },
+        });
+        console.log(`Published ${result.record.slug}@${result.record.version}`);
+        console.log(`  id: ${result.record.id}`);
+        console.log(`  checksum: ${result.record.integrity.checksum}`);
+    }
+    catch (err) {
+        printRegistryError(err);
+        process.exit(1);
+    }
+}
+async function deprecateSubcommand(args) {
+    const ref = parseRegistryReference(args[0] ?? '');
+    if (!ref) {
+        console.error('Usage: aman registry deprecate @scope/name@X.Y.Z --reason "..." [--successor @scope/name@X.Y.Z]');
+        process.exit(1);
+    }
+    let reason = '';
+    let successor;
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--reason' && args[i + 1])
+            reason = args[++i];
+        else if (args[i] === '--successor' && args[i + 1])
+            successor = args[++i];
+    }
+    if (!reason) {
+        console.error('Required: --reason');
+        process.exit(1);
+    }
+    try {
+        const result = await registryService.deprecate({
+            slug: ref.slug,
+            version: ref.version,
+            reason,
+            successor,
+        });
+        console.log(`Deprecated ${ref.slug}@${ref.version}`);
+        console.log(`  reason: ${result.record.deprecated?.reason}`);
+    }
+    catch (err) {
+        printRegistryError(err);
+        process.exit(1);
+    }
+}
+async function listSubcommand(args) {
+    const slug = args[0];
+    if (!slug?.startsWith('@')) {
+        console.error('Usage: aman registry list @scope/name');
+        process.exit(1);
+    }
+    try {
+        const result = await registryService.list({ slug });
+        console.log(`${result.slug} (${result.id})`);
+        for (const v of result.versions) {
+            const dep = v.deprecated ? ' [deprecated]' : '';
+            console.log(`  ${v.version}${dep}  ${v.integrity.checksum}`);
+        }
+    }
+    catch (err) {
+        printRegistryError(err);
+        process.exit(1);
+    }
+}
+async function searchSubcommand(query) {
+    const result = await registryService.search({ query });
+    for (const hit of result.hits) {
+        const dep = hit.record.deprecated ? ' [deprecated]' : '';
+        const verified = hit.record.trust.verified ? ' verified' : '';
+        console.log(`${hit.slug}@${hit.latestVersion}${dep}${verified}  downloads:${hit.record.trust.downloads}`);
+    }
+    if (result.hits.length === 0) {
+        console.log('No matches.');
+    }
+}
+async function resolveSubcommand(args) {
+    const ref = parseRegistryReference(args[0] ?? '');
+    if (!ref) {
+        console.error('Usage: aman registry resolve @scope/name@X.Y.Z');
+        process.exit(1);
+    }
+    try {
+        const resolved = await registryService.resolve(ref);
+        console.log(JSON.stringify(resolved.record, null, 2));
+    }
+    catch (err) {
+        printRegistryError(err);
+        process.exit(1);
+    }
+}
+/** Publish from an installed global asset path (convenience for bootstrapping). */
+export async function publishInstalledAsset(localName, type, slug, version) {
+    const root = environmentService.getActiveEnvironmentDir();
+    const typeRoot = type === 'skill'
+        ? path.join(root, 'skills')
+        : type === 'prompt'
+            ? path.join(root, 'prompts')
+            : path.join(root, 'mcps');
+    const contentDirectory = assetDir(type, typeRoot, localName);
+    await registryService.publish({
+        slug,
+        version,
+        type,
+        contentDirectory,
+        metadata: {
+            id: registryService.newPublishId(),
+            slug,
+            type,
+            name: localName,
+            description: '',
+            version,
+            author: 'local',
+            tags: [],
+            visibility: 'public',
+            dependencies: [],
+        },
+    });
+}

package/dist/commands/remove.d.ts

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

package/dist/commands/remove.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { render, Box, useApp } from 'ink';
+import { assetService } from '../services/asset.service.js';
+import { Confirm } from '../ui/components/Confirm.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { titleize } from '../ui/marketplaceDisplay.js';
+import { ASSET_TAB_ORDER } from '../ui/assetDisplay.js';
+const RemoveApp = ({ name, scope, skipConfirm }) => {
+    const { exit } = useApp();
+    const [confirmed, setConfirmed] = useState(skipConfirm);
+    const [state, setState] = useState('idle');
+    const [message, setMessage] = useState('');
+    useEffect(() => {
+        if (!confirmed)
+            return;
+        async function doRemove() {
+            setState('installing');
+            setMessage(`Removing ${titleize(name)}...`);
+            const types = ['skill', 'prompt', 'mcp'];
+            let removed = false;
+            for (const t of types) {
+                try {
+                    const result = await assetService.remove(name, t, scope);
+                    if (result)
+                        removed = true;
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (removed) {
+                setState('success');
+                setMessage(`Removed ${titleize(name)} from ${scope === 'project' ? 'project' : 'global'}`);
+            }
+            else {
+                setState('error');
+                setMessage(`Could not find ${titleize(name)} in ${scope === 'project' ? 'project' : 'global'}`);
+            }
+            setTimeout(() => exit(), 800);
+        }
+        doRemove();
+    }, [confirmed, exit, name, scope]);
+    if (!confirmed) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Confirm, { message: `Remove ${titleize(name)}?`, onConfirm: () => setConfirmed(true), onCancel: () => {
+                    console.log('  Cancelled.');
+                    exit();
+                } }) }));
+    }
+    return (_jsx(Box, { paddingX: 1, children: _jsx(Narrator, { state: state, message: message }) }));
+};
+export async function removeCommand(args, options) {
+    const name = args.join(' ');
+    if (!name) {
+        console.log('  Usage: aman remove <name>');
+        return;
+    }
+    const scope = options.project || options.p ? 'project' : 'global';
+    let skipConfirm = Boolean(options.yes || options.y);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        let removed = false;
+        for (const type of ASSET_TAB_ORDER) {
+            if (await assetService.remove(name, type, scope)) {
+                removed = true;
+            }
+        }
+        if (removed) {
+            console.log(`Removed ${titleize(name)} from ${scope === 'project' ? 'project' : 'global'}`);
+            return;
+        }
+        console.error(`Could not find ${titleize(name)} in ${scope === 'project' ? 'project' : 'global'}`);
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(RemoveApp, { name: name, scope: scope, skipConfirm: skipConfirm }));
+    await waitUntilExit();
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,7 @@
+export declare const SearchApp: ({ onBack, initialQuery }: {
+    onBack?: () => void;
+    initialQuery?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function searchCommand(args: string[], options?: {
+    noTty?: boolean;
+}): Promise<void>;