aman-intelligence 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,146 @@
+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 TextInput from 'ink-text-input';
+import { environmentService } from '../services/environment.service.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+const storageItems = [
+    { label: 'GitHub (recommended)', value: 'github' },
+    { label: 'Local only', value: 'local' },
+];
+const githubModeItems = [
+    { label: 'Create a new private repo', value: 'create' },
+    { label: 'Use an existing repo', value: 'existing' },
+];
+export const InitFlow = ({ startWithGithub, repository, githubMode = 'create', exitOnDone = true, onDone, }) => {
+    const { exit } = useApp();
+    const [screen, setScreen] = useState(startWithGithub ? 'githubMode' : 'storage');
+    const [selectedGithubMode, setSelectedGithubMode] = useState(githubMode);
+    const [repoValue, setRepoValue] = useState(repository || '');
+    const [repoError, setRepoError] = useState();
+    const finish = (result) => {
+        onDone(result);
+        if (exitOnDone) {
+            exit();
+        }
+    };
+    useInput((input, key) => {
+        if (input === 'q') {
+            finish({ action: 'exit' });
+            return;
+        }
+        if (key.escape) {
+            if (screen === 'repo') {
+                setScreen('githubMode');
+            }
+            else if (screen === 'githubMode') {
+                if (startWithGithub) {
+                    finish({ action: 'exit' });
+                }
+                else {
+                    setScreen('storage');
+                }
+            }
+            else if (screen === 'storage') {
+                finish({ action: 'exit' });
+            }
+        }
+    });
+    useEffect(() => {
+        if (repository && screen === 'githubMode') {
+            finish({ action: 'github', repository, mode: githubMode });
+        }
+    }, [githubMode, repository, screen]);
+    if (screen === 'storage') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { children: "Where should aman store your environment?" }), _jsx(Text, { color: theme.dim, children: "GitHub syncs and backs up your environment." }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: storageItems, onSelect: (item) => {
+                            if (item.value === 'github')
+                                setScreen('githubMode');
+                            if (item.value === 'local')
+                                finish({ action: 'local' });
+                        } }) })] }));
+    }
+    if (screen === 'githubMode') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { children: "How should aman connect to GitHub?" }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: githubModeItems, onSelect: (item) => {
+                            setSelectedGithubMode(item.value);
+                            setScreen('repo');
+                        } }) })] }));
+    }
+    if (screen === 'repo') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { children: selectedGithubMode === 'existing' ? 'Which GitHub repo should aman use?' : 'Name your aman GitHub repo.' }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.primary, children: '> ' }), _jsx(TextInput, { value: repoValue, onChange: (value) => {
+                                setRepoValue(value);
+                                setRepoError(undefined);
+                            }, placeholder: selectedGithubMode === 'existing' ? 'github-user/repo' : 'aman-environment', onSubmit: (value) => {
+                                const trimmed = value.trim();
+                                if (!trimmed) {
+                                    setRepoError('Enter a repository name to continue.');
+                                    return;
+                                }
+                                finish({ action: 'github', repository: trimmed, mode: selectedGithubMode });
+                            } })] }), repoError && (_jsx(Text, { color: theme.error, children: repoError }))] }));
+    }
+    return null;
+};
+async function renderInitFlow(options = {}) {
+    let result = { action: 'exit' };
+    const { waitUntilExit } = render(_jsx(InitFlow, { ...options, onDone: (nextResult) => { result = nextResult; } }));
+    await waitUntilExit();
+    return result;
+}
+async function completeLocalInit(storagePath) {
+    console.log('  ◌ Setting up local environment...');
+    const environmentPath = await environmentService.initLocal({ storagePath });
+    console.log(`  ✓ Environment ready: ${environmentPath}`);
+    console.log('');
+    console.log('  Next: aman browse');
+}
+async function completeGithubInit(repository, mode) {
+    if (!environmentService.isGithubCliAvailable()) {
+        console.log('  ◌ Installing GitHub CLI...');
+        environmentService.installGithubCli();
+        console.log('  ✓ GitHub CLI ready.');
+    }
+    console.log(`  ◌ Setting up GitHub environment: ${repository}`);
+    const environmentPath = await environmentService.initGithub({ repository, mode });
+    console.log(`  ✓ Environment ready: ${environmentPath}`);
+    console.log('');
+    console.log('  Next: aman browse');
+}
+async function completeInitResult(result, options) {
+    if (result.action === 'exit') {
+        console.log('  Setup paused. Run aman init when ready.');
+        return;
+    }
+    if (result.action === 'local') {
+        await completeLocalInit(options.path);
+        return;
+    }
+    await completeGithubInit(result.repository, result.mode);
+}
+export async function initCommand(args, options) {
+    const wantsGithub = Boolean(options.github);
+    const wantsLocal = Boolean(options.local);
+    if (wantsGithub && wantsLocal) {
+        console.log('  Choose either --github or --local, not both.');
+        return;
+    }
+    if (wantsLocal) {
+        await completeLocalInit(options.path || args[0]);
+        return;
+    }
+    if (!process.stdin.isTTY && !wantsGithub && !wantsLocal) {
+        console.log('  Non-interactive mode detected. Initializing local storage by default...');
+        await completeLocalInit(options.path || args[0]);
+        return;
+    }
+    if (wantsGithub) {
+        const repository = options.repo || options.repository || args[0];
+        const mode = options.existing ? 'existing' : 'create';
+        const result = await renderInitFlow({ startWithGithub: true, repository, githubMode: mode });
+        await completeInitResult(result, options);
+        return;
+    }
+    const result = await renderInitFlow();
+    await completeInitResult(result, options);
+}

package/dist/commands/install.d.ts

@@ -0,0 +1,10 @@
+export declare const InstallWizardApp: ({ onBack }: {
+    onBack?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function installCommand(args: string[], options: {
+    project?: boolean;
+    p?: boolean;
+    global?: boolean;
+    g?: boolean;
+    type?: string;
+}): Promise<void>;

package/dist/commands/install.js

@@ -0,0 +1,342 @@
+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 TextInput from 'ink-text-input';
+import { CustomSelectInput } from '../ui/components/CustomSelect.js';
+import { assetService } from '../services/asset.service.js';
+import { marketplaceService } from '../services/marketplace.service.js';
+import { registryService, isRegistryInstallReference } from '../registry/registry.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 { shortDescription, titleize } from '../ui/marketplaceDisplay.js';
+import { ASSET_TAB_ORDER, ASSET_TYPE_PLURAL } from '../ui/assetDisplay.js';
+import { TransitionScreen } from '../ui/animations/TransitionScreen.js';
+import { MarketplaceInstallConfirm } from '../ui/components/MarketplaceInstallConfirm.js';
+import { installFromCandidate } from '../marketplace/install-from-candidate.js';
+import { MARKETPLACE_ENABLED } from '../config/features.js';
+import { environmentService } from '../services/environment.service.js';
+function scopeLabel(scope) {
+    return scope === 'project' ? 'project' : 'global';
+}
+function assertInstallEnvironment(scope) {
+    if (!environmentService.isEnvironmentInitialized(scope)) {
+        console.error('\n  Aman Intelligence is not initialized yet.');
+        console.error(`  Run the following command to get started:\n`);
+        console.error(`  aman init --local\n`);
+        process.exit(1);
+    }
+}
+function assetLookupFailureMessage(name) {
+    return MARKETPLACE_ENABLED
+        ? `Could not find "${name}" in marketplace or bundled assets`
+        : `Could not find "${name}" in registry or local assets`;
+}
+async function runHeadlessInstall(name, scope, assetType) {
+    const candidate = await marketplaceService.findInstallCandidate(name);
+    if (candidate) {
+        const result = await installFromCandidate(candidate, scope);
+        console.log(`Installed ${ASSET_TYPE_PLURAL[candidate.type].slice(0, -1)} ${titleize(candidate.name)} → ${result.path}`);
+        return;
+    }
+    const types = assetType ? [assetType] : ASSET_TAB_ORDER;
+    for (const type of types) {
+        try {
+            await assetService.install(name, type, scope, undefined, 'local');
+            console.log(`Installed ${type} ${name} → ${scopeLabel(scope)}`);
+            return;
+        }
+        catch {
+            // try next type
+        }
+    }
+    console.error(`Could not find or install "${name}".`);
+    process.exit(1);
+}
+const InstallApp = ({ name, initialScope, initialType }) => {
+    const { exit } = useApp();
+    const [scope, setScope] = useState(initialScope);
+    const [assetType, setAssetType] = useState(initialType);
+    const [candidate, setCandidate] = useState(null);
+    const [registryRef, setRegistryRef] = useState(null);
+    const [lookupDone, setLookupDone] = useState(false);
+    const [confirmDone, setConfirmDone] = useState(false);
+    const [state, setState] = useState('searching');
+    const [message, setMessage] = useState(`Looking up ${name}...`);
+    useInput((input) => {
+        if (input === 'q')
+            exit();
+    });
+    useEffect(() => {
+        let active = true;
+        async function lookup() {
+            try {
+                const parsedRegistry = registryService.parseInstallReference(name);
+                if (parsedRegistry) {
+                    if (!active)
+                        return;
+                    setRegistryRef(parsedRegistry);
+                    setLookupDone(true);
+                    setMessage(`Registry: ${parsedRegistry.slug}@${parsedRegistry.version}`);
+                    return;
+                }
+                const types = assetType ? [assetType] : ASSET_TAB_ORDER;
+                let match = null;
+                for (const type of types) {
+                    const results = await marketplaceService.search(name, type);
+                    const found = results.find((item) => item.name.toLowerCase() === name.toLowerCase().replace(/\s+/g, '-'));
+                    if (found) {
+                        match = await marketplaceService.findInstallCandidate(found.name);
+                        if (match)
+                            break;
+                    }
+                }
+                if (!match) {
+                    match = await marketplaceService.findInstallCandidate(name);
+                }
+                if (!active)
+                    return;
+                if (!match) {
+                    setState('error');
+                    setMessage(assetLookupFailureMessage(name));
+                    setLookupDone(true);
+                    setTimeout(() => exit(), 1800);
+                    return;
+                }
+                setCandidate(match);
+                setAssetType(match.type);
+                setLookupDone(true);
+                setMessage(`Found ${ASSET_TYPE_PLURAL[match.type].slice(0, -1)}: ${titleize(match.name)}`);
+            }
+            catch (err) {
+                if (!active)
+                    return;
+                setState('error');
+                setMessage(`Error: ${err.message}`);
+                setLookupDone(true);
+                setTimeout(() => exit(), 1800);
+            }
+        }
+        lookup();
+        return () => {
+            active = false;
+        };
+    }, [exit, name, assetType]);
+    useEffect(() => {
+        if (!scope || !lookupDone || !registryRef)
+            return;
+        async function doRegistryInstall() {
+            try {
+                setState('installing');
+                setMessage(`Installing ${registryRef.slug}@${registryRef.version}...`);
+                const result = await registryService.installFromRegistry(registryRef.slug, registryRef.version, scope);
+                for (const warning of result.warnings) {
+                    console.warn(warning);
+                }
+                setState('success');
+                setMessage(`Installed ${result.localName} (${registryRef.slug}@${registryRef.version}) → ${scopeLabel(scope)}`);
+                setTimeout(() => exit(), 800);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(`Error: ${err.message}`);
+                setTimeout(() => exit(), 1600);
+            }
+        }
+        doRegistryInstall();
+    }, [registryRef, exit, lookupDone, scope]);
+    useEffect(() => {
+        if (!scope || !lookupDone || !candidate || registryRef || !confirmDone)
+            return;
+        const selectedScope = scope;
+        async function doInstall() {
+            try {
+                setState('installing');
+                setMessage(`Installing ${titleize(candidate.name)}...`);
+                const result = await installFromCandidate(candidate, selectedScope);
+                setState('success');
+                setMessage(`Installed ${ASSET_TYPE_PLURAL[candidate.type].slice(0, -1)} ${titleize(candidate.name)} → ${result.path}`);
+                setTimeout(() => exit(), 800);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(`Error: ${err instanceof Error ? err.message : String(err)}`);
+                setTimeout(() => exit(), 1600);
+            }
+        }
+        doInstall();
+    }, [candidate, exit, lookupDone, scope, name, confirmDone]);
+    if (!lookupDone) {
+        return (_jsx(Box, { paddingX: 1, flexDirection: "column", children: _jsx(Narrator, { state: "searching", message: message }) }));
+    }
+    if (!scope &&
+        state !== 'error' &&
+        candidate?.marketplaceAsset &&
+        lookupDone &&
+        !confirmDone) {
+        const gh = candidate.marketplaceAsset;
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsx(MarketplaceInstallConfirm, { details: {
+                    name: gh.localName,
+                    type: gh.type,
+                    slug: gh.slug,
+                    author: gh.author,
+                    version: gh.version,
+                    source: gh.source,
+                    checksum: gh.checksum,
+                    verified: gh.verified,
+                }, onConfirm: (s) => {
+                    setConfirmDone(true);
+                    setScope(s);
+                }, onCancel: () => exit() }) }));
+    }
+    if (!scope && state !== 'error' && (candidate || registryRef)) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: registryRef
+                        ? `${registryRef.slug}@${registryRef.version}`
+                        : `${titleize(candidate.name)} (${candidate.type})` }), candidate?.description && (_jsx(Text, { color: theme.dim, children: shortDescription(candidate.description) })), _jsx(Box, { marginTop: 1, children: _jsx(ScopePrompt, { onSelect: (s) => {
+                            setConfirmDone(true);
+                            setScope(s);
+                        } }) })] }));
+    }
+    return (_jsx(Box, { paddingX: 1, flexDirection: "column", children: _jsx(Narrator, { state: state, message: message }) }));
+};
+export const InstallWizardApp = ({ onBack }) => {
+    const { exit } = useApp();
+    const handleExit = () => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    };
+    const [step, setStep] = useState('type');
+    const [assetType, setAssetType] = useState(ASSET_TAB_ORDER[0]);
+    const [source, setSource] = useState(MARKETPLACE_ENABLED ? 'marketplace' : 'local');
+    const [name, setName] = useState('');
+    const [scope, setScope] = useState();
+    const [state, setState] = useState('idle');
+    const [message, setMessage] = useState('');
+    useInput((input, key) => {
+        if (key.escape || input === 'q')
+            handleExit();
+    });
+    useEffect(() => {
+        if (step !== 'installing' || !scope || !name.trim())
+            return;
+        async function run() {
+            setState('installing');
+            setMessage(`Installing ${titleize(name)}...`);
+            try {
+                if (source === 'marketplace') {
+                    const candidate = await marketplaceService.findInstallCandidate(name);
+                    if (!candidate)
+                        throw new Error(`"${name}" not found in marketplace`);
+                    await installFromCandidate(candidate, scope);
+                }
+                else {
+                    await assetService.install(name, assetType, scope, undefined, source);
+                }
+                setState('success');
+                setMessage(`Installed ${ASSET_TYPE_PLURAL[assetType].slice(0, -1)} ${titleize(name)} → ${scopeLabel(scope)}`);
+            }
+            catch (err) {
+                setState('error');
+                setMessage(err.message);
+            }
+            setStep('done');
+            setTimeout(() => handleExit(), 1200);
+        }
+        run();
+    }, [step, scope, name, assetType, source]);
+    if (step === 'type') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, color: theme.accent, children: "Install Asset" }), _jsx(Text, { color: theme.dim, children: "Type" }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: ASSET_TAB_ORDER.map((t) => ({
+                            label: `${t === assetType ? '❯ ' : '  '}${ASSET_TYPE_PLURAL[t].slice(0, -1)}`,
+                            value: t,
+                        })), onSelect: (item) => {
+                            setAssetType(item.value);
+                            setStep('source');
+                        } }) })] }));
+    }
+    if (step === 'source') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, color: theme.accent, children: "Install Asset" }), _jsx(Text, { color: theme.dim, children: "Source" }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: MARKETPLACE_ENABLED
+                            ? [
+                                { label: '❯ Marketplace', value: 'marketplace' },
+                                { label: '  Local / Registry', value: 'local' },
+                                { label: '  GitHub', value: 'github' },
+                            ]
+                            : [
+                                { label: '❯ Registry / Local', value: 'local' },
+                                { label: '  GitHub', value: 'github' },
+                            ], onSelect: (item) => {
+                            setSource(item.value);
+                            setStep('name');
+                        } }) })] }));
+    }
+    if (step === 'name') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsxs(Text, { bold: true, color: theme.accent, children: ["Install ", ASSET_TYPE_PLURAL[assetType].slice(0, -1)] }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { color: theme.primary, children: "\u276F " }), _jsx(TextInput, { value: name, onChange: setName, onSubmit: () => setStep('scope'), placeholder: "Asset name..." })] }), _jsx(Text, { color: theme.dim, children: "press enter to continue" })] }));
+    }
+    if (step === 'scope') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), _jsx(Text, { bold: true, children: titleize(name) }), _jsxs(Text, { color: theme.dim, children: [ASSET_TYPE_PLURAL[assetType].slice(0, -1), " \u00B7 ", source] }), _jsx(Box, { marginTop: 1, children: _jsx(ScopePrompt, { onSelect: (s) => {
+                            setScope(s);
+                            setStep('installing');
+                        } }) })] }));
+    }
+    return (_jsx(Box, { paddingX: 1, children: _jsx(Narrator, { state: state, message: message }) }));
+};
+export async function installCommand(args, options) {
+    const name = args.join(' ').trim();
+    if (isRegistryInstallReference(name)) {
+        const registryRef = registryService.parseInstallReference(name);
+        let scope = options.project || options.p
+            ? 'project'
+            : options.global || options.g
+                ? 'global'
+                : undefined;
+        if (!scope) {
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                console.error('Registry install requires --global or --project when not interactive.');
+                process.exit(1);
+            }
+            const { waitUntilExit } = render(_jsx(TransitionScreen, { message: `Preparing registry install for ${name}...`, children: _jsx(InstallApp, { name: name, initialScope: undefined }) }));
+            await waitUntilExit();
+            return;
+        }
+        assertInstallEnvironment(scope);
+        const result = await registryService.installFromRegistry(registryRef.slug, registryRef.version, scope);
+        for (const warning of result.warnings) {
+            console.warn(warning);
+        }
+        console.log(`Installed ${result.localName} (${registryRef.slug}@${registryRef.version}) → ${scope}`);
+        return;
+    }
+    let initialScope = options.project || options.p
+        ? 'project'
+        : options.global || options.g
+            ? 'global'
+            : undefined;
+    const typeFlag = options.type;
+    const initialType = typeFlag && ASSET_TAB_ORDER.includes(typeFlag) ? typeFlag : undefined;
+    if (!name) {
+        if (!process.stdin.isTTY) {
+            console.log('  Usage: aman install <name> [--global|--project] [--type skill|prompt|mcp]');
+            return;
+        }
+        const { waitUntilExit } = render(_jsx(InstallWizardApp, {}));
+        await waitUntilExit();
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        if (!initialScope) {
+            console.error('Install requires --global or --project when not interactive.\n' +
+                'Example: aman install my-skill --global');
+            process.exit(1);
+        }
+        assertInstallEnvironment(initialScope);
+        await runHeadlessInstall(name, initialScope, initialType);
+        return;
+    }
+    if (initialScope) {
+        assertInstallEnvironment(initialScope);
+    }
+    const { waitUntilExit } = render(_jsx(TransitionScreen, { message: `Preparing installation for ${name}...`, children: _jsx(InstallApp, { name: name, initialScope: initialScope, initialType: initialType }) }));
+    await waitUntilExit();
+}

package/dist/commands/pack.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { Scope } from '../types/index.js';
+interface PackCreateAppProps {
+    name: string;
+}
+export declare const PackCreateApp: React.FC<PackCreateAppProps & {
+    onBack?: () => void;
+}>;
+interface PackInspectAppProps {
+    packPath: string;
+}
+export declare const PackInspectApp: React.FC<PackInspectAppProps & {
+    onBack?: () => void;
+}>;
+interface PackInstallAppProps {
+    packPath: string;
+    initialScope?: Scope;
+}
+export declare const PackInstallApp: React.FC<PackInstallAppProps & {
+    onBack?: () => void;
+}>;
+export declare function packCommand(args: string[], options: any): Promise<void>;
+export {};