aman-intelligence 0.1.0

package/dist/commands/sync.js

@@ -0,0 +1,428 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useCallback } 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 { lockService } from '../services/lock.service.js';
+import { exists } from '../storage/filesystem.js';
+import { Narrator } from '../ui/components/Narrator.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+import { execFileSync } from 'child_process';
+import { useResponsiveLayout, MIN_COLUMNS, MIN_ROWS } from '../ui/layout.js';
+import { TooSmallScreen } from '../ui/components/TooSmallScreen.js';
+import { ProgressBar } from '../ui/animations/ProgressBar.js';
+import { TransitionScreen } from '../ui/animations/TransitionScreen.js';
+function parseGitError(err) {
+    const stderr = err.stderr ? err.stderr.toString() : err.message || '';
+    if (stderr.includes('Repository not found') || stderr.includes('does not exist')) {
+        return 'GitHub Repository not found. Verify the repo name or run "gh repo create" to establish it.';
+    }
+    if (stderr.includes('Permission to') && stderr.includes('denied')) {
+        return 'Permission denied. Ensure your GitHub CLI account has push access to this repository.';
+    }
+    if (stderr.includes('Authentication failed') || stderr.includes('Could not read from remote repository')) {
+        return 'GitHub Authentication failed. Please run "gh auth login" to refresh your session.';
+    }
+    if (stderr.includes('detached HEAD')) {
+        return 'Git is in a detached HEAD state. Run "git checkout main" manually in the environment directory first.';
+    }
+    if (stderr.includes('conflict') || stderr.includes('non-fast-forward') || stderr.includes('Updates were rejected')) {
+        return 'Push conflict: remote changes exist. Run "aman sync pull" first to merge differences.';
+    }
+    if (stderr.includes('branch') && (stderr.includes('does not exist') || stderr.includes('not found'))) {
+        return 'Target branch does not exist on the remote repository.';
+    }
+    if (stderr.includes('remote rejected')) {
+        return 'Remote repository rejected the push. Check remote branch restrictions or permissions.';
+    }
+    if (stderr.includes('Could not resolve host') || stderr.includes('network') || stderr.includes('connection')) {
+        return 'Network failure. Check your internet connection and try again.';
+    }
+    return stderr.trim() || 'Git operation failed';
+}
+export const SyncApp = ({ action, onBack }) => {
+    const { exit } = useApp();
+    const { rows, isTooSmall, physicalColumns, physicalRows } = useResponsiveLayout();
+    const [progress, setProgress] = useState(0);
+    const handleExit = useCallback(() => {
+        if (onBack)
+            onBack();
+        else
+            exit();
+    }, [onBack, exit]);
+    const [screenState, setScreenState] = useState('checking');
+    const [githubMode, setGithubMode] = useState('create');
+    const [repoName, setRepoName] = useState('');
+    const [repoError, setRepoError] = useState();
+    const [setupState, setSetupState] = useState('idle');
+    const [setupMessage, setSetupMessage] = useState('');
+    if (isTooSmall) {
+        return _jsx(TooSmallScreen, { columns: physicalColumns, rows: physicalRows, minColumns: MIN_COLUMNS, minRows: MIN_ROWS });
+    }
+    const [mochiState, setMochiState] = useState('searching');
+    const [message, setMessage] = useState('');
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            if (screenState === 'mode_select') {
+                setScreenState('not_connected_menu');
+            }
+            else if (screenState === 'repo_input') {
+                setScreenState('mode_select');
+            }
+            else if (screenState === 'gh_cli_required') {
+                setScreenState('not_connected_menu');
+            }
+            else if (screenState === 'not_connected_menu' ||
+                screenState === 'local_storage_info' ||
+                screenState === 'done') {
+                handleExit();
+            }
+        }
+    });
+    // Check connection on start
+    useEffect(() => {
+        if (screenState === 'checking') {
+            const storage = environmentService.getStorage();
+            if (storage.type === 'github' && storage.repository) {
+                setScreenState('sync_loading');
+            }
+            else {
+                setScreenState('not_connected_menu');
+            }
+        }
+    }, [screenState]);
+    // Handle local storage info auto-exit
+    useEffect(() => {
+        if (screenState === 'local_storage_info') {
+            const t = setTimeout(() => handleExit(), 3000);
+            return () => clearTimeout(t);
+        }
+    }, [screenState, handleExit]);
+    async function handleSetupAndSync(repo) {
+        setScreenState('setup_loading');
+        setSetupState('installing');
+        setSetupMessage(`Setting up GitHub repository: ${repo}...`);
+        try {
+            await environmentService.initGithub({ repository: repo, mode: githubMode });
+            setSetupState('success');
+            setSetupMessage('GitHub connected successfully! Starting sync...');
+            setTimeout(() => {
+                setScreenState('sync_loading');
+            }, 1200);
+        }
+        catch (err) {
+            setSetupState('error');
+            setSetupMessage(`Setup failed: ${err.message}`);
+            setTimeout(() => {
+                handleExit();
+            }, 2500);
+        }
+    }
+    useEffect(() => {
+        async function runSync() {
+            try {
+                setProgress(10);
+                const storage = environmentService.getStorage();
+                if (storage.type !== 'github' || !storage.repository) {
+                    setMochiState('error');
+                    setMessage('No GitHub storage configured.');
+                    setScreenState('done');
+                    setTimeout(() => handleExit(), 2000);
+                    return;
+                }
+                const repoDir = environmentService.getActiveEnvironmentDir();
+                if (!exists(repoDir)) {
+                    setMochiState('error');
+                    setMessage(`Active environment directory does not exist: ${repoDir}`);
+                    setScreenState('done');
+                    setTimeout(() => handleExit(), 2000);
+                    return;
+                }
+                setProgress(25);
+                // Verify git is installed and directory is git repo
+                try {
+                    execFileSync('git', ['-C', repoDir, 'status'], { stdio: 'ignore' });
+                }
+                catch {
+                    // Initialize git repo if not already
+                    try {
+                        execFileSync('git', ['-C', repoDir, 'init'], { stdio: 'ignore' });
+                        execFileSync('git', ['-C', repoDir, 'remote', 'add', 'origin', `https://github.com/${storage.repository}.git`], { stdio: 'ignore' });
+                    }
+                    catch {
+                        setMochiState('error');
+                        setMessage('Git is not installed or configured correctly in the environment directory.');
+                        setScreenState('done');
+                        setTimeout(() => handleExit(), 2000);
+                        return;
+                    }
+                }
+                setProgress(35);
+                // Read lockfile to count assets before sync
+                const beforeLock = await lockService.read('global');
+                const beforeSkills = beforeLock.assets.filter((a) => a.type === 'skill').length;
+                const beforePrompts = beforeLock.assets.filter((a) => a.type === 'prompt').length;
+                const beforeMcps = beforeLock.assets.filter((a) => a.type === 'mcp').length;
+                if (action === 'push') {
+                    setMochiState('syncing');
+                    setMessage(`Pushing to ${storage.repository}...`);
+                    setProgress(50);
+                    try {
+                        execFileSync('git', ['-C', repoDir, 'add', '.'], { stdio: 'ignore' });
+                        // Check if there is anything to commit
+                        let hasChanges = true;
+                        try {
+                            execFileSync('git', ['-C', repoDir, 'diff', '--cached', '--quiet'], { stdio: 'ignore' });
+                            hasChanges = false;
+                        }
+                        catch {
+                            // diff returns non-zero when there are changes, so this is expected
+                        }
+                        setProgress(65);
+                        if (hasChanges) {
+                            const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 19);
+                            execFileSync('git', ['-C', repoDir, 'commit', '-m', `Sync environment: ${timestamp}`], { stdio: 'ignore' });
+                        }
+                        setProgress(80);
+                        // Push origin main/master
+                        let pushSuccess = false;
+                        let lastErr = null;
+                        for (const branch of ['main', 'master']) {
+                            try {
+                                execFileSync('git', ['-C', repoDir, 'push', 'origin', branch], { stdio: 'pipe' });
+                                pushSuccess = true;
+                                break;
+                            }
+                            catch (err) {
+                                lastErr = err;
+                            }
+                        }
+                        if (!pushSuccess) {
+                            try {
+                                execFileSync('git', ['-C', repoDir, 'push', '-u', 'origin', 'HEAD'], { stdio: 'pipe' });
+                            }
+                            catch (err) {
+                                throw lastErr || err;
+                            }
+                        }
+                        setProgress(100);
+                        setMochiState('success');
+                        setMessage(`Synced ${beforeMcps} MCP${beforeMcps !== 1 ? 's' : ''}, ${beforePrompts} prompt${beforePrompts !== 1 ? 's' : ''}, ${beforeSkills} skill${beforeSkills !== 1 ? 's' : ''}`);
+                    }
+                    catch (err) {
+                        throw new Error(parseGitError(err));
+                    }
+                }
+                else if (action === 'pull') {
+                    setMochiState('syncing');
+                    setMessage(`Pulling from ${storage.repository}...`);
+                    setProgress(50);
+                    try {
+                        let pullSuccess = false;
+                        let lastErr = null;
+                        for (const branch of ['main', 'master']) {
+                            try {
+                                execFileSync('git', ['-C', repoDir, 'pull', '--rebase', 'origin', branch], { stdio: 'pipe' });
+                                pullSuccess = true;
+                                break;
+                            }
+                            catch (err) {
+                                lastErr = err;
+                            }
+                        }
+                        setProgress(80);
+                        if (!pullSuccess) {
+                            try {
+                                execFileSync('git', ['-C', repoDir, 'pull', '--rebase', 'origin', 'HEAD'], { stdio: 'pipe' });
+                            }
+                            catch (err) {
+                                throw lastErr || err;
+                            }
+                        }
+                        // Read lockfile again after pull
+                        const afterLock = await lockService.read('global');
+                        const afterSkills = afterLock.assets.filter((a) => a.type === 'skill').length;
+                        const afterPrompts = afterLock.assets.filter((a) => a.type === 'prompt').length;
+                        const afterMcps = afterLock.assets.filter((a) => a.type === 'mcp').length;
+                        setProgress(100);
+                        setMochiState('success');
+                        setMessage(`Pulled ${afterMcps} MCP${afterMcps !== 1 ? 's' : ''}, ${afterPrompts} prompt${afterPrompts !== 1 ? 's' : ''}, ${afterSkills} skill${afterSkills !== 1 ? 's' : ''}`);
+                    }
+                    catch (err) {
+                        throw new Error(parseGitError(err));
+                    }
+                }
+                setScreenState('done');
+                setTimeout(() => handleExit(), 1500);
+            }
+            catch (err) {
+                setProgress(0);
+                setMochiState('error');
+                setMessage(`Sync error: ${err.message}`);
+                setScreenState('done');
+                setTimeout(() => handleExit(), 2500);
+            }
+        }
+        if (screenState === 'sync_loading') {
+            runSync();
+        }
+    }, [screenState, action, handleExit]);
+    if (screenState === 'checking') {
+        return (_jsx(Box, { paddingX: 1, height: rows, justifyContent: "center", alignItems: "center", children: _jsx(Narrator, { state: "searching", message: "Checking connection..." }) }));
+    }
+    if (screenState === 'not_connected_menu') {
+        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: "GitHub is not connected." }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                                    { label: 'Connect GitHub', value: 'connect' },
+                                    { label: 'Use Local Storage Only', value: 'local' },
+                                    { label: 'Back', value: 'back' },
+                                ], onSelect: async (item) => {
+                                    if (item.value === 'connect') {
+                                        if (!environmentService.isGithubCliAvailable()) {
+                                            setScreenState('gh_cli_required');
+                                        }
+                                        else {
+                                            setScreenState('mode_select');
+                                        }
+                                    }
+                                    else if (item.value === 'local') {
+                                        setScreenState('local_storage_info');
+                                    }
+                                    else {
+                                        handleExit();
+                                    }
+                                } }) })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press enter to select \u00B7 esc exit" }) })] }));
+    }
+    if (screenState === 'gh_cli_required') {
+        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.error, children: "GitHub CLI is required." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Please install it via https://cli.github.com or using your package manager:" }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { color: theme.secondary, children: "\u2022 Windows:  winget install GitHub.cli" }), _jsx(Text, { color: theme.secondary, children: "\u2022 macOS:    brew install gh" }), _jsx(Text, { color: theme.secondary, children: "\u2022 Linux:    sudo apt install gh" })] }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                                    { label: 'Continue With Local Storage', value: 'local' },
+                                    { label: 'Back', value: 'back' },
+                                ], onSelect: async (item) => {
+                                    if (item.value === 'local') {
+                                        setScreenState('setup_loading');
+                                        setSetupState('installing');
+                                        setSetupMessage('Configuring local folder...');
+                                        try {
+                                            await environmentService.initLocal({});
+                                            setSetupState('success');
+                                            setSetupMessage('Local environment initialized!');
+                                            setTimeout(() => {
+                                                setScreenState('local_storage_info');
+                                            }, 1200);
+                                        }
+                                        catch (err) {
+                                            setSetupState('error');
+                                            setSetupMessage(`Setup failed: ${err.message}`);
+                                            setTimeout(() => {
+                                                handleExit();
+                                            }, 2500);
+                                        }
+                                    }
+                                    else {
+                                        setScreenState('not_connected_menu');
+                                    }
+                                } }) })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press enter to select" }) })] }));
+    }
+    if (screenState === 'mode_select') {
+        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: "Connect GitHub" }), _jsx(Box, { marginTop: 1, children: _jsx(CustomSelectInput, { items: [
+                                    { label: 'Create New Repository', value: 'create' },
+                                    { label: 'Use Existing Repository', value: 'existing' },
+                                ], onSelect: (item) => {
+                                    setGithubMode(item.value);
+                                    setScreenState('repo_input');
+                                } }) })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press enter to select \u00B7 esc go back" }) })] }));
+    }
+    if (screenState === 'repo_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: githubMode === 'existing' ? 'Which GitHub repo should aman use?' : 'Name your aman GitHub repo.' }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { color: theme.primary, children: "Repository Name: " }), _jsx(TextInput, { value: repoName, onChange: (val) => {
+                                        setRepoName(val);
+                                        setRepoError(undefined);
+                                    }, placeholder: githubMode === 'existing' ? 'github-user/repo' : 'aman-environment', onSubmit: async (val) => {
+                                        const trimmed = val.trim();
+                                        if (!trimmed) {
+                                            setRepoError('Enter a repository name to continue.');
+                                            return;
+                                        }
+                                        await handleSetupAndSync(trimmed);
+                                    } })] }), repoError && _jsx(Text, { color: theme.error, children: repoError })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press enter to submit \u00B7 esc go back" }) })] }));
+    }
+    if (screenState === 'setup_loading') {
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: setupState, message: setupMessage })] }) }));
+    }
+    if (screenState === 'local_storage_info') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { compact: true }), _jsx(Text, { color: theme.warning, children: "Local storage does not support cloud sync." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.dim, children: "Please connect a GitHub repository to enable push/pull workflows." }) })] }), _jsx(Box, { children: _jsx(Text, { color: theme.dim, children: "press esc or q to exit" }) })] }));
+    }
+    if (screenState === 'sync_loading') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: mochiState, message: message }), _jsx(Box, { marginTop: 1, children: _jsx(ProgressBar, { progress: progress }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: rows, children: [_jsx(Header, { compact: true }), _jsx(Narrator, { state: mochiState, message: message })] }));
+};
+export async function syncCommand(args) {
+    const action = args[0];
+    if (action !== 'push' && action !== 'pull') {
+        console.log('  Usage: aman sync <push|pull>');
+        process.exit(1);
+    }
+    if (!process.stdin.isTTY) {
+        console.log(`  ◌ Non-interactive mode: executing sync ${action}...`);
+        try {
+            const storage = environmentService.getStorage();
+            if (storage.type !== 'github' || !storage.repository) {
+                console.log('  ✗ Sync error: No GitHub storage configured. Run "aman init" first.');
+                process.exit(1);
+            }
+            const repoDir = environmentService.getActiveEnvironmentDir();
+            if (action === 'push') {
+                execFileSync('git', ['-C', repoDir, 'add', '.'], { stdio: 'ignore' });
+                try {
+                    execFileSync('git', ['-C', repoDir, 'diff', '--cached', '--quiet'], { stdio: 'ignore' });
+                }
+                catch {
+                    const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 19);
+                    execFileSync('git', ['-C', repoDir, 'commit', '-m', `Sync environment: ${timestamp}`], { stdio: 'ignore' });
+                }
+                let pushSuccess = false;
+                let lastErr = null;
+                for (const branch of ['main', 'master']) {
+                    try {
+                        execFileSync('git', ['-C', repoDir, 'push', 'origin', branch], { stdio: 'pipe' });
+                        pushSuccess = true;
+                        break;
+                    }
+                    catch (err) {
+                        lastErr = err;
+                    }
+                }
+                if (!pushSuccess && lastErr) {
+                    throw lastErr;
+                }
+                console.log(`  ✓ Synced environment to ${storage.repository}`);
+            }
+            else {
+                let pullSuccess = false;
+                let lastErr = null;
+                for (const branch of ['main', 'master']) {
+                    try {
+                        execFileSync('git', ['-C', repoDir, 'pull', '--rebase', 'origin', branch], { stdio: 'pipe' });
+                        pullSuccess = true;
+                        break;
+                    }
+                    catch (err) {
+                        lastErr = err;
+                    }
+                }
+                if (!pullSuccess && lastErr) {
+                    throw lastErr;
+                }
+                console.log(`  ✓ Pulled environment changes from ${storage.repository}`);
+            }
+            return;
+        }
+        catch (err) {
+            console.log(`  ✗ Sync error: ${parseGitError(err)}`);
+            process.exit(1);
+        }
+    }
+    const { waitUntilExit } = render(_jsx(TransitionScreen, { message: `Starting repository sync (${action})...`, children: _jsx(SyncApp, { action: action }) }));
+    await waitUntilExit();
+}

package/dist/commands/update.d.ts

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

package/dist/commands/update.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { render, Box, Text, useApp } from 'ink';
+import { assetService } from '../services/asset.service.js';
+import { lockService } from '../services/lock.service.js';
+import { marketplaceService } from '../services/marketplace.service.js';
+import { Header } from '../ui/components/Header.js';
+import { theme } from '../ui/theme.js';
+import { titleize } from '../ui/marketplaceDisplay.js';
+import { Spinner } from '../ui/animations/Spinner.js';
+import { TransitionScreen } from '../ui/animations/TransitionScreen.js';
+import { installFromCandidate } from '../marketplace/install-from-candidate.js';
+const UpdateApp = ({ names, scope }) => {
+    const { exit } = useApp();
+    const [results, setResults] = useState([]);
+    const [current, setCurrent] = useState('');
+    const [done, setDone] = useState(false);
+    useEffect(() => {
+        async function doUpdate() {
+            const updateResults = [];
+            for (const name of names) {
+                setCurrent(name);
+                const candidate = await marketplaceService.findInstallCandidate(name);
+                if (!candidate) {
+                    updateResults.push({ name, success: false });
+                    setResults([...updateResults]);
+                    continue;
+                }
+                try {
+                    await assetService.install(candidate.name, candidate.type, scope, candidate.sourcePath, candidate.source);
+                    updateResults.push({ name, success: true });
+                }
+                catch {
+                    updateResults.push({ name, success: false });
+                }
+                setResults([...updateResults]);
+            }
+            setDone(true);
+            setTimeout(() => exit(), 1000);
+        }
+        doUpdate();
+    }, [exit, names, scope]);
+    const passed = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Header, { compact: true }), results.map((r) => (_jsxs(Text, { children: [_jsxs(Text, { color: r.success ? theme.success : theme.error, bold: true, children: [r.success ? '✓' : '✗', ' '] }), _jsx(Text, { children: titleize(r.name) }), !r.success && _jsx(Text, { color: theme.dim, children: " (source not found)" })] }, r.name))), !done && current && (_jsx(Spinner, { label: `Updating ${titleize(current)}...` })), done && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.dim, children: ["Updated ", passed, failed > 0 ? `, failed ${failed}` : ''] }) }))] }));
+};
+async function installedNames(scope) {
+    const lockfile = await lockService.read(scope);
+    return lockfile.assets.map((entry) => entry.localName);
+}
+export async function updateCommand(args, options = {}) {
+    const scope = options.project || options.p ? 'project' : 'global';
+    const specificName = args.find((arg) => !arg.startsWith('--'));
+    let names;
+    if (specificName) {
+        names = [specificName];
+    }
+    else {
+        // No name = update all
+        names = await installedNames(scope);
+        if (names.length === 0) {
+            console.log(`  No installed items in ${scope}.`);
+            return;
+        }
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        let passed = 0;
+        let failed = 0;
+        for (const name of names) {
+            const candidate = await marketplaceService.findInstallCandidate(name);
+            if (!candidate) {
+                console.log(`  ✗ ${titleize(name)} (not found)`);
+                failed++;
+                continue;
+            }
+            try {
+                if (candidate.marketplaceAsset) {
+                    await installFromCandidate(candidate, scope);
+                }
+                else {
+                    await assetService.install(candidate.name, candidate.type, scope, candidate.sourcePath, candidate.source);
+                }
+                console.log(`  ✓ ${titleize(name)}`);
+                passed++;
+            }
+            catch {
+                console.log(`  ✗ ${titleize(name)}`);
+                failed++;
+            }
+        }
+        console.log(`\n  Updated ${passed}${failed > 0 ? `, failed ${failed}` : ''}\n`);
+        return;
+    }
+    console.log(`  Updating ${names.length} item${names.length !== 1 ? 's' : ''}...\n`);
+    const { waitUntilExit } = render(_jsx(TransitionScreen, { message: "Scanning for updates...", children: _jsx(UpdateApp, { names: names, scope: scope }) }));
+    await waitUntilExit();
+}

package/dist/config/features.d.ts

@@ -0,0 +1,2 @@
+/** GitHub topic marketplace (disabled until a future release). */
+export declare const MARKETPLACE_ENABLED = false;

package/dist/config/features.js

@@ -0,0 +1,2 @@
+/** GitHub topic marketplace (disabled until a future release). */
+export const MARKETPLACE_ENABLED = false;

package/dist/config/index.d.ts

@@ -0,0 +1,13 @@
+import { AmanConfig } from '../types/index.js';
+declare class ConfigManager {
+    private globalConf;
+    constructor();
+    load(): AmanConfig;
+    get<K extends keyof AmanConfig>(key: K): AmanConfig[K];
+    set<K extends keyof AmanConfig>(key: K, value: AmanConfig[K]): void;
+    reset(): void;
+    getTheme(): 'dark' | 'light';
+    onDidChange<K extends keyof AmanConfig>(key: K, callback: (value?: AmanConfig[K]) => void): () => void;
+}
+export declare const config: ConfigManager;
+export {};

package/dist/config/index.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import Conf from 'conf';
+import { GLOBAL_CONFIG_DIR } from './paths.js';
+import path from 'path';
+const defaultConfig = {
+    theme: 'auto',
+    defaultScope: 'global',
+    environmentPath: undefined,
+    storage: undefined,
+    marketplaces: ['skills.sh'],
+    animationMode: 'normal',
+};
+class ConfigManager {
+    globalConf;
+    constructor() {
+        try {
+            this.globalConf = new Conf({
+                projectName: 'aman',
+                cwd: GLOBAL_CONFIG_DIR,
+                configName: 'aman',
+                defaults: defaultConfig,
+            });
+        }
+        catch (err) {
+            const configPath = path.join(GLOBAL_CONFIG_DIR, 'aman.json');
+            if (fs.existsSync(configPath)) {
+                const timestamp = new Date().toISOString().slice(0, 10);
+                const backupPath = path.join(GLOBAL_CONFIG_DIR, `aman.json.corrupted-${timestamp}`);
+                try {
+                    fs.renameSync(configPath, backupPath);
+                }
+                catch {
+                    // Ignore
+                }
+            }
+            console.error('\n  \x1b[31;1mConfiguration file was corrupted.\x1b[0m');
+            console.error('  \x1b[33mA backup was created.\x1b[0m');
+            console.error('  \x1b[32mDefaults have been restored.\x1b[0m\n');
+            this.globalConf = new Conf({
+                projectName: 'aman',
+                cwd: GLOBAL_CONFIG_DIR,
+                configName: 'aman',
+                defaults: defaultConfig,
+            });
+        }
+    }
+    load() {
+        return this.globalConf.store;
+    }
+    get(key) {
+        return this.globalConf.get(key);
+    }
+    set(key, value) {
+        this.globalConf.set(key, value);
+    }
+    reset() {
+        this.globalConf.clear();
+        this.globalConf.store = defaultConfig;
+    }
+    getTheme() {
+        const theme = this.get('theme');
+        if (theme === 'auto') {
+            const colorfgbg = process.env.COLORFGBG;
+            if (colorfgbg) {
+                const parts = colorfgbg.split(';');
+                const bg = parts[parts.length - 1];
+                const bgNum = parseInt(bg, 10);
+                if (!isNaN(bgNum)) {
+                    return bgNum >= 7 && bgNum !== 8 ? 'light' : 'dark';
+                }
+            }
+            return 'dark';
+        }
+        return theme;
+    }
+    onDidChange(key, callback) {
+        return this.globalConf.onDidChange(key, callback);
+    }
+}
+export const config = new ConfigManager();

package/dist/config/paths.d.ts

@@ -0,0 +1,23 @@
+export declare const GLOBAL_DIR: string;
+export declare const GLOBAL_SKILLS: string;
+export declare const GLOBAL_PROMPTS: string;
+export declare const GLOBAL_MCPS: string;
+export declare const GLOBAL_STACKS: string;
+export declare const GLOBAL_CACHE: string;
+export declare const GLOBAL_BACKUPS: string;
+export declare const GLOBAL_REGISTRY_DIR: string;
+export declare const GLOBAL_CONFIG_DIR: string;
+export declare const GLOBAL_CONFIG_FILE: string;
+export declare const LOCAL_DIR = ".aman";
+export declare const LOCAL_CONFIG_FILE: string;
+export declare const LOCAL_LOCKFILE: string;
+export declare const PROJECT_ROOT: string;
+export declare const BUNDLED_SKILLS: string;
+export declare const BUNDLED_PROMPTS: string;
+export declare const BUNDLED_MCPS: string;
+/**
+ * Creates all `~/.aman/` subdirectories.
+ * This is used during setup and doctor checks.
+ */
+export declare function ensureGlobalDirs(): Promise<void>;
+export declare function ensureProjectDirs(): Promise<void>;