symphony-github 0.1.0

package/dist/components/Onboarding.js

@@ -0,0 +1,948 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { Box, Text, useApp, useInput, useStdout } from 'ink';
+import BigText from 'ink-big-text';
+import SelectInput from 'ink-select-input';
+import Spinner from 'ink-spinner';
+import { runSafe } from '../utils/shell.js';
+import { colors, gradient, progressBar, GradientText } from '../theme.js';
+import { buildOnboardingConfigYaml } from '../config/index.js';
+const RUN_MODES = [
+    { value: 'auto', label: 'Auto', desc: 'fully autonomous: run, push, resolve conflicts, and merge PRs' },
+    { value: 'auto_manual_conflicts', label: 'Auto (manual conflicts)', desc: 'run, push, open PRs, and merge automatically; stop for merge conflicts' },
+    { value: 'auto_manual_merge', label: 'Auto (manual merge)', desc: 'run, push, and open PRs automatically; stop before the final merge' },
+];
+const TRIGGER_MODES = [
+    { value: 'mention_or_label', label: 'Mention or label', desc: 'agent mention or "agent" label' },
+    { value: 'mention_only', label: 'Mention only', desc: 'only configured agent mentions' },
+    { value: 'label_only', label: 'Label only', desc: 'only "agent" label on the issue' },
+    { value: 'mention_and_label', label: 'Mention and label', desc: 'require both an agent mention and label' },
+    { value: 'yolo', label: 'Every issue', desc: 'run on all open issues' },
+    { value: 'disabled', label: 'Disabled', desc: 'pause automatic issue triggering' },
+];
+const AUTOMATION_LEVELS = [
+    { value: 'bypassPermissions', label: 'Hands-off', desc: 'let the agent act autonomously' },
+    { value: 'acceptEdits', label: 'Review commands', desc: 'auto-accept edits, ask before risky commands' },
+    { value: 'plan', label: 'Plan only', desc: 'inspect and propose changes only' },
+    { value: '', label: 'Use agent defaults', desc: 'each agent decides its own permission level' },
+];
+const STARTUP_SCAN_OPTIONS = [
+    { value: 'disabled', label: 'No existing-issue scan on start', desc: 'default; only react to new updates after startup' },
+    { value: 'enabled', label: 'Scan existing open issues on start', desc: 'check selected repos for already-open matching issues and start them on launch' },
+];
+const GITHUB_COMMENT_OPTIONS = [
+    { value: 'key_updates', label: 'Just key updates', desc: 'post milestones like start, review, merge, and final result' },
+    { value: 'without_thinking', label: 'Without thinking traces', desc: 'post progress and final status without raw terminal reasoning output' },
+    { value: 'full', label: 'Full verbosity', desc: 'mirror live progress with terminal excerpts, including thinking traces' },
+    { value: 'silent', label: 'Silent', desc: 'do not post Symphony progress comments back to GitHub' },
+];
+const SCOPE_OPTIONS = [
+    { value: 'all', label: 'Watch all repositories', desc: 'include every repository for this owner' },
+    { value: 'manual', label: 'Choose repositories manually', desc: 'pick only specific repositories' },
+];
+const DEFAULT_POLL_INTERVAL_SEC = 2;
+function targetLabel(target) {
+    return target.kind === 'user' ? `${target.login} (your account)` : target.login;
+}
+function buildDefaultMentionItems(defaultAgent, installedAgents) {
+    const items = [{ mention: '@agent', agent: defaultAgent }];
+    const seen = new Set(['@agent']);
+    for (const agent of installedAgents) {
+        const mention = `@${agent}`;
+        if (seen.has(mention))
+            continue;
+        seen.add(mention);
+        items.push({ mention, agent });
+    }
+    return items;
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+function inferAutomationMode(settings) {
+    if (!settings)
+        return '';
+    const modes = unique(Object.values(settings.agents)
+        .map(agent => agent.permission_mode ?? '')
+        .filter((mode) => mode === '' || mode === 'plan' || mode === 'acceptEdits' || mode === 'bypassPermissions'));
+    return modes.length === 1 ? modes[0] : '';
+}
+function buildMentionItemsFromSettings(settings) {
+    if (!settings)
+        return [];
+    const items = [];
+    const seen = new Set();
+    const orderedMentions = [
+        '@agent',
+        ...Object.keys(settings.routing.mention_map).filter(mention => mention !== '@agent'),
+        ...settings.trigger.mentions,
+    ];
+    for (const mention of orderedMentions) {
+        const normalized = normalizeMention(mention);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        items.push({
+            mention: normalized,
+            agent: settings.routing.mention_map[normalized] || settings.default_agent,
+        });
+    }
+    return items;
+}
+function normalizeMention(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    return trimmed.startsWith('@') ? trimmed : `@${trimmed}`;
+}
+function flattenSelectedRepos(targets) {
+    return targets
+        .filter(target => target.selected)
+        .flatMap(target => target.repos.filter(repo => repo.selected).map(repo => repo.name));
+}
+function uniqueMentionItems(items) {
+    const seen = new Set();
+    const unique = [];
+    for (const item of items) {
+        const mention = normalizeMention(item.mention);
+        if (!mention || seen.has(mention))
+            continue;
+        seen.add(mention);
+        unique.push({ mention, agent: item.agent });
+    }
+    return unique;
+}
+// ── Custom SelectInput components ──────────────────────────────────
+const SelectIndicator = ({ isSelected }) => (React.createElement(Text, { color: colors.primaryLight }, isSelected ? ' ▸ ' : '   '));
+const SelectItem = ({ isSelected, label }) => (React.createElement(Text, { color: isSelected ? colors.primaryLight : colors.text, bold: isSelected }, label));
+export const Onboarding = ({ configPath, flow = 'setup', initialSettings, baseConfig, onComplete, onExit, }) => {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const termWidth = stdout?.columns || 80;
+    const configuredAgentNames = useMemo(() => unique([
+        ...Object.keys(initialSettings?.agents || {}),
+        initialSettings?.default_agent || '',
+        ...Object.values(initialSettings?.routing.mention_map || {}),
+    ].filter(Boolean)), [initialSettings]);
+    const initialMentionItems = useMemo(() => buildMentionItemsFromSettings(initialSettings), [initialSettings]);
+    const initialReposByOwner = useMemo(() => {
+        const reposByOwner = new Map();
+        for (const repoSetting of initialSettings?.repos || []) {
+            const [owner] = repoSetting.repo.split('/', 1);
+            if (!owner)
+                continue;
+            if (!reposByOwner.has(owner))
+                reposByOwner.set(owner, new Set());
+            reposByOwner.get(owner).add(repoSetting.repo);
+        }
+        return reposByOwner;
+    }, [initialSettings]);
+    const initialSelectedOwners = useMemo(() => new Set(initialReposByOwner.keys()), [initialReposByOwner]);
+    const initialRunModeIdx = useMemo(() => {
+        const idx = RUN_MODES.findIndex(mode => mode.value === initialSettings?.mode);
+        return idx >= 0 ? idx : 2;
+    }, [initialSettings]);
+    const initialTriggerModeIdx = useMemo(() => {
+        const idx = TRIGGER_MODES.findIndex(mode => mode.value === initialSettings?.trigger.mode);
+        return idx >= 0 ? idx : 0;
+    }, [initialSettings]);
+    const initialAutomationIdx = useMemo(() => {
+        const mode = inferAutomationMode(initialSettings);
+        const idx = AUTOMATION_LEVELS.findIndex(option => option.value === mode);
+        return idx >= 0 ? idx : AUTOMATION_LEVELS.length - 1;
+    }, [initialSettings]);
+    const initialGitHubCommentIdx = useMemo(() => {
+        const idx = GITHUB_COMMENT_OPTIONS.findIndex(option => option.value === initialSettings?.github_comments.verbosity);
+        return idx >= 0 ? idx : 0;
+    }, [initialSettings]);
+    const [step, setStep] = useState('env');
+    const [envChecks, setEnvChecks] = useState([]);
+    const [envDone, setEnvDone] = useState(false);
+    const [scopeTargets, setScopeTargets] = useState([]);
+    const [scopeIdx, setScopeIdx] = useState(0);
+    const [currentTargetIdx, setCurrentTargetIdx] = useState(0);
+    const [repoIdx, setRepoIdx] = useState(0);
+    const [repoSearch, setRepoSearch] = useState('');
+    const [repoSearchActive, setRepoSearchActive] = useState(false);
+    const [installedAgents, setInstalledAgents] = useState([]);
+    const [defaultAgent, setDefaultAgent] = useState(initialSettings?.default_agent || 'claude');
+    const [mentionItems, setMentionItems] = useState(initialMentionItems);
+    const [mentionIdx, setMentionIdx] = useState(0);
+    const [mentionEditActive, setMentionEditActive] = useState(false);
+    const [mentionInput, setMentionInput] = useState('');
+    const [runModeIdx, setRunModeIdx] = useState(initialRunModeIdx);
+    const [triggerModeIdx, setTriggerModeIdx] = useState(initialTriggerModeIdx);
+    const [startupScanIdx, setStartupScanIdx] = useState(initialSettings?.trigger.include_existing_open_issues ? 1 : 0);
+    const [automationIdx, setAutomationIdx] = useState(initialAutomationIdx);
+    const [githubCommentIdx, setGitHubCommentIdx] = useState(initialGitHubCommentIdx);
+    const [doneIdx, setDoneIdx] = useState(0);
+    const [loading, setLoading] = useState('');
+    const currentTarget = scopeTargets[currentTargetIdx] || null;
+    const currentRepos = currentTarget?.repos || [];
+    const filteredRepos = repoSearch
+        ? currentRepos.filter(repo => repo.name.toLowerCase().includes(repoSearch.toLowerCase()))
+        : currentRepos;
+    const selectedRepos = flattenSelectedRepos(scopeTargets);
+    const draftRepos = selectedRepos.length > 0
+        ? selectedRepos
+        : (flow === 'reconfigure' && scopeTargets.length === 0
+            ? (initialSettings?.repos || []).map(repo => repo.repo)
+            : []);
+    const uniqueMentions = uniqueMentionItems(mentionItems.length > 0 ? mentionItems : buildDefaultMentionItems(defaultAgent, installedAgents));
+    const selectedTargetIndices = scopeTargets.reduce((acc, target, idx) => {
+        if (target.selected)
+            acc.push(idx);
+        return acc;
+    }, []);
+    const loadGitHubScopes = useCallback(async () => {
+        setLoading('Loading GitHub accounts and organizations...');
+        const [userResult, orgResult] = await Promise.all([
+            runSafe('gh', ['api', 'user', '--jq', '.login']),
+            runSafe('gh', ['api', 'user/orgs', '--jq', '.[].login']),
+        ]);
+        setLoading('');
+        if (userResult.exitCode !== 0 || !userResult.stdout.trim()) {
+            setLoading('Unable to load GitHub scopes. Continuing without repositories.');
+            setTimeout(() => {
+                setLoading('');
+                setStep('agent-default');
+            }, 1500);
+            return;
+        }
+        const login = userResult.stdout.trim();
+        const orgLogins = orgResult.exitCode === 0
+            ? orgResult.stdout.split('\n').map(line => line.trim()).filter(Boolean)
+            : [];
+        const targets = [
+            {
+                login,
+                kind: 'user',
+                selected: initialSelectedOwners.size > 0 ? initialSelectedOwners.has(login) : true,
+                watchAll: initialSelectedOwners.has(login) ? false : true,
+                reposLoaded: false,
+                repos: [],
+            },
+            ...orgLogins
+                .filter(org => org !== login)
+                .map(org => ({
+                login: org,
+                kind: 'org',
+                selected: initialSelectedOwners.has(org),
+                watchAll: initialSelectedOwners.has(org) ? false : true,
+                reposLoaded: false,
+                repos: [],
+            })),
+        ];
+        setScopeTargets(targets);
+        setScopeIdx(0);
+        if (targets.length === 1 && targets[0].kind === 'user') {
+            setCurrentTargetIdx(0);
+            setStep('scope-mode');
+            return;
+        }
+        setStep('scope-select');
+    }, [initialSelectedOwners]);
+    const fetchReposForTarget = useCallback(async (targetIdx, selectAll, preselectedRepos) => {
+        const target = scopeTargets[targetIdx];
+        if (!target)
+            return false;
+        setLoading(`Fetching repositories for ${target.login}...`);
+        const result = await runSafe('gh', [
+            'repo', 'list', target.login,
+            '--limit', '1000',
+            '--json', 'nameWithOwner',
+            '-q', '.[].nameWithOwner',
+        ]);
+        setLoading('');
+        if (result.exitCode !== 0) {
+            setLoading(`Unable to load repositories for ${target.login}.`);
+            setTimeout(() => setLoading(''), 1500);
+            return false;
+        }
+        const existingSelections = new Set(target.repos.filter(repo => repo.selected).map(repo => repo.name));
+        for (const repo of preselectedRepos || []) {
+            existingSelections.add(repo);
+        }
+        const repos = result.stdout
+            .split('\n')
+            .map(line => line.trim())
+            .filter(Boolean)
+            .map(name => ({
+            name,
+            selected: selectAll || existingSelections.has(name),
+        }));
+        setScopeTargets(prev => prev.map((item, idx) => (idx === targetIdx
+            ? { ...item, watchAll: selectAll, reposLoaded: true, repos }
+            : item)));
+        setRepoIdx(0);
+        setRepoSearch('');
+        setRepoSearchActive(false);
+        return true;
+    }, [scopeTargets]);
+    const goToTarget = useCallback((targetIdx) => {
+        const target = scopeTargets[targetIdx];
+        if (!target)
+            return;
+        setCurrentTargetIdx(targetIdx);
+        setStep('scope-mode');
+    }, [scopeTargets]);
+    const goToNextTarget = useCallback((fromTargetIdx) => {
+        const nextIdx = selectedTargetIndices.find(idx => idx > fromTargetIdx);
+        if (nextIdx === undefined) {
+            setStep('agent-default');
+            return;
+        }
+        goToTarget(nextIdx);
+    }, [goToTarget, selectedTargetIndices]);
+    const includeAllReposForSelectedTargets = useCallback(async () => {
+        const selectedIndices = scopeTargets.reduce((acc, target, idx) => {
+            if (target.selected)
+                acc.push(idx);
+            return acc;
+        }, []);
+        if (selectedIndices.length === 0) {
+            setLoading('Select at least one account or organization.');
+            setTimeout(() => setLoading(''), 1500);
+            return;
+        }
+        for (const idx of selectedIndices) {
+            const target = scopeTargets[idx];
+            if (!target)
+                continue;
+            const alreadyLoadedAll = target.reposLoaded
+                && target.watchAll
+                && target.repos.length > 0
+                && target.repos.every(repo => repo.selected);
+            if (!alreadyLoadedAll) {
+                const ok = await fetchReposForTarget(idx, true);
+                if (!ok)
+                    return;
+            }
+        }
+        setStep('agent-default');
+    }, [fetchReposForTarget, scopeTargets]);
+    useEffect(() => {
+        (async () => {
+            const checks = [];
+            const git = await runSafe('git', ['--version']);
+            checks.push({ name: 'git', ok: git.exitCode === 0, detail: git.exitCode === 0 ? git.stdout.split(' ')[2] : undefined });
+            const gh = await runSafe('gh', ['auth', 'status']);
+            checks.push({ name: 'gh', ok: gh.exitCode === 0, detail: gh.exitCode === 0 ? 'authenticated' : 'not authenticated' });
+            const tmux = await runSafe('tmux', ['-V']);
+            checks.push({ name: 'tmux', ok: tmux.exitCode === 0, detail: tmux.exitCode === 0 ? tmux.stdout : 'not installed' });
+            const agentBins = [
+                { name: 'claude', cmd: 'command -v claude' },
+                { name: 'codex', cmd: 'command -v codex' },
+                { name: 'opencode', cmd: 'command -v opencode' },
+                { name: 'gemini', cmd: 'command -v gemini' },
+                { name: 'cline', cmd: 'command -v cline' },
+                { name: 'copilot', cmd: 'command -v copilot' },
+            ];
+            const found = [];
+            for (const agent of agentBins) {
+                const result = await runSafe('sh', ['-c', agent.cmd]);
+                const ok = result.exitCode === 0;
+                checks.push({ name: agent.name, ok, detail: ok ? undefined : 'not found' });
+                if (ok)
+                    found.push(agent.name);
+            }
+            const resolvedAgents = unique([
+                ...configuredAgentNames,
+                ...(found.length > 0 ? found : ['claude']),
+            ]);
+            const initialAgent = initialSettings?.default_agent && resolvedAgents.includes(initialSettings.default_agent)
+                ? initialSettings.default_agent
+                : (resolvedAgents.includes('claude') ? 'claude' : resolvedAgents[0]);
+            setInstalledAgents(resolvedAgents);
+            setDefaultAgent(initialAgent);
+            setMentionItems(initialMentionItems.length > 0
+                ? initialMentionItems
+                : buildDefaultMentionItems(initialAgent, resolvedAgents));
+            setEnvChecks(checks);
+            setEnvDone(true);
+        })();
+    }, [configuredAgentNames, initialMentionItems, initialSettings?.default_agent]);
+    const buildDraft = useCallback(() => ({
+        defaultAgent,
+        configuredAgents: unique([
+            ...configuredAgentNames,
+            ...(flow === 'setup' && !initialSettings ? installedAgents : []),
+            defaultAgent,
+            ...uniqueMentions.map(item => item.agent),
+        ]),
+        repos: draftRepos,
+        mentionItems: uniqueMentions,
+        runMode: RUN_MODES[runModeIdx].value,
+        triggerMode: TRIGGER_MODES[triggerModeIdx].value,
+        includeExistingOpenIssues: STARTUP_SCAN_OPTIONS[startupScanIdx].value === 'enabled',
+        automationMode: AUTOMATION_LEVELS[automationIdx].value,
+        githubCommentVerbosity: GITHUB_COMMENT_OPTIONS[githubCommentIdx].value,
+    }), [
+        automationIdx,
+        configuredAgentNames,
+        defaultAgent,
+        flow,
+        githubCommentIdx,
+        initialSettings,
+        installedAgents,
+        runModeIdx,
+        draftRepos,
+        startupScanIdx,
+        triggerModeIdx,
+        uniqueMentions,
+    ]);
+    const buildConfigYaml = useCallback(() => {
+        const draft = buildDraft();
+        return buildOnboardingConfigYaml(baseConfig, draft);
+    }, [baseConfig, buildDraft]);
+    // ── Keyboard: only handle Esc (back), q (quit), and custom steps ──
+    useInput(useCallback((input, key) => {
+        // Mention editing mode
+        if (mentionEditActive && step === 'agent-mentions') {
+            if (key.escape) {
+                setMentionEditActive(false);
+                setMentionInput('');
+                return;
+            }
+            if (key.return) {
+                const normalized = normalizeMention(mentionInput);
+                if (normalized) {
+                    setMentionItems(prev => prev.map((item, idx) => idx === mentionIdx ? { ...item, mention: normalized } : item));
+                }
+                setMentionEditActive(false);
+                setMentionInput('');
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setMentionInput(prev => prev.slice(0, -1));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setMentionInput(prev => prev + input);
+                return;
+            }
+            return;
+        }
+        // Repo search mode
+        if (repoSearchActive && step === 'repo-select') {
+            if (key.escape) {
+                setRepoSearchActive(false);
+                setRepoSearch('');
+                return;
+            }
+            if (key.return) {
+                setRepoSearchActive(false);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setRepoSearch(prev => prev.slice(0, -1));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setRepoSearch(prev => prev + input);
+                setRepoIdx(0);
+                return;
+            }
+            return;
+        }
+        if (input === 'q' && step !== 'done') {
+            onExit();
+            if (flow !== 'reconfigure')
+                exit();
+            return;
+        }
+        // Esc navigation (back)
+        if (key.escape) {
+            switch (step) {
+                case 'scope-select':
+                    setStep('env');
+                    break;
+                case 'scope-mode':
+                    if (scopeTargets.length > 1)
+                        setStep('scope-select');
+                    else
+                        setStep('env');
+                    break;
+                case 'repo-select':
+                    setStep('scope-mode');
+                    break;
+                case 'agent-default':
+                    if (selectedTargetIndices.length > 0)
+                        goToTarget(selectedTargetIndices[selectedTargetIndices.length - 1]);
+                    else if (scopeTargets.length > 0)
+                        setStep('scope-select');
+                    else
+                        setStep('env');
+                    break;
+                case 'agent-mentions':
+                    setStep('agent-default');
+                    break;
+                case 'run-mode':
+                    setStep('agent-mentions');
+                    break;
+                case 'trigger-mode':
+                    setStep('run-mode');
+                    break;
+                case 'startup-scan':
+                    setStep('trigger-mode');
+                    break;
+                case 'automation':
+                    setStep('startup-scan');
+                    break;
+                case 'github-comments':
+                    setStep('automation');
+                    break;
+                case 'done':
+                    setStep('github-comments');
+                    break;
+            }
+            return;
+        }
+        // Step-specific keyboard (only for steps not handled by SelectInput/MultiSelect)
+        switch (step) {
+            case 'env':
+                if (key.return && envDone)
+                    void loadGitHubScopes();
+                break;
+            case 'scope-select':
+                if (key.upArrow)
+                    setScopeIdx(prev => Math.max(0, prev - 1));
+                if (key.downArrow)
+                    setScopeIdx(prev => Math.min(scopeTargets.length - 1, prev + 1));
+                if (input === ' ') {
+                    const target = scopeTargets[scopeIdx];
+                    if (!target)
+                        break;
+                    setScopeTargets(prev => prev.map((item, idx) => (idx === scopeIdx ? { ...item, selected: !item.selected } : item)));
+                }
+                if (key.return) {
+                    void includeAllReposForSelectedTargets();
+                }
+                if (input === 'm') {
+                    if (selectedTargetIndices.length === 0) {
+                        setLoading('Select at least one account or organization.');
+                        setTimeout(() => setLoading(''), 1500);
+                        break;
+                    }
+                    const selectedLogins = new Set(scopeTargets
+                        .filter(target => target.selected)
+                        .map(target => target.login));
+                    const firstSelectedIdx = scopeTargets.findIndex(target => selectedLogins.has(target.login));
+                    if (firstSelectedIdx === -1) {
+                        setStep('agent-default');
+                    }
+                    else {
+                        goToTarget(firstSelectedIdx);
+                    }
+                }
+                break;
+            case 'repo-select':
+                if (key.upArrow)
+                    setRepoIdx(prev => Math.max(0, prev - 1));
+                if (key.downArrow)
+                    setRepoIdx(prev => Math.min(filteredRepos.length - 1, prev + 1));
+                if (input === ' ') {
+                    const repo = filteredRepos[repoIdx];
+                    if (!repo)
+                        break;
+                    setScopeTargets(prev => prev.map((target, idx) => (idx !== currentTargetIdx ? target : {
+                        ...target,
+                        repos: target.repos.map(item => item.name === repo.name ? { ...item, selected: !item.selected } : item),
+                    })));
+                }
+                if (input === 'a') {
+                    const visibleNames = new Set(filteredRepos.map(repo => repo.name));
+                    const allVisibleSelected = filteredRepos.length > 0 && filteredRepos.every(repo => repo.selected);
+                    setScopeTargets(prev => prev.map((target, idx) => (idx !== currentTargetIdx ? target : {
+                        ...target,
+                        repos: target.repos.map(repo => visibleNames.has(repo.name) ? { ...repo, selected: !allVisibleSelected } : repo),
+                    })));
+                }
+                if (input === '/') {
+                    setRepoSearchActive(true);
+                    setRepoSearch('');
+                }
+                if (key.return)
+                    goToNextTarget(currentTargetIdx);
+                break;
+            case 'agent-mentions':
+                if (key.upArrow)
+                    setMentionIdx(prev => Math.max(0, prev - 1));
+                if (key.downArrow)
+                    setMentionIdx(prev => Math.min(mentionItems.length - 1, prev + 1));
+                if (input === 'e' && mentionItems[mentionIdx]) {
+                    setMentionEditActive(true);
+                    setMentionInput(mentionItems[mentionIdx].mention);
+                }
+                if (input === 'r') {
+                    setMentionItems(buildDefaultMentionItems(defaultAgent, installedAgents));
+                    setMentionIdx(0);
+                }
+                if (key.return)
+                    setStep('run-mode');
+                break;
+        }
+    }, [
+        currentTargetIdx, defaultAgent, envDone, exit, fetchReposForTarget,
+        filteredRepos, goToNextTarget, goToTarget, includeAllReposForSelectedTargets, installedAgents, loadGitHubScopes,
+        mentionEditActive, mentionIdx, mentionInput, mentionItems, onComplete, onExit,
+        repoIdx, repoSearchActive, scopeIdx, scopeTargets, selectedTargetIndices, step,
+    ]));
+    // ── SelectInput callbacks ────────────────────────────────────────
+    const handleScopeModeSelect = useCallback((item) => {
+        if (!currentTarget)
+            return;
+        if (item.value === 'all') {
+            void (async () => {
+                const ok = await fetchReposForTarget(currentTargetIdx, true);
+                if (ok)
+                    goToNextTarget(currentTargetIdx);
+            })();
+        }
+        else {
+            void (async () => {
+                const ok = currentTarget.reposLoaded || await fetchReposForTarget(currentTargetIdx, false, initialReposByOwner.get(currentTarget.login));
+                if (ok) {
+                    setScopeTargets(prev => prev.map((target, idx) => (idx === currentTargetIdx ? { ...target, watchAll: false } : target)));
+                    setRepoIdx(0);
+                    setRepoSearch('');
+                    setRepoSearchActive(false);
+                    setStep('repo-select');
+                }
+            })();
+        }
+    }, [currentTarget, currentTargetIdx, fetchReposForTarget, goToNextTarget, initialReposByOwner]);
+    const handleAgentSelect = useCallback((item) => {
+        setDefaultAgent(item.value);
+        setMentionItems(buildDefaultMentionItems(item.value, installedAgents));
+        setMentionIdx(0);
+        setStep('agent-mentions');
+    }, [installedAgents]);
+    const handleRunModeSelect = useCallback((item) => {
+        const idx = RUN_MODES.findIndex(m => m.value === item.value);
+        if (idx >= 0)
+            setRunModeIdx(idx);
+        setStep('trigger-mode');
+    }, []);
+    const handleTriggerSelect = useCallback((item) => {
+        const idx = TRIGGER_MODES.findIndex(m => m.value === item.value);
+        if (idx >= 0)
+            setTriggerModeIdx(idx);
+        setStep('startup-scan');
+    }, []);
+    const handleStartupScanSelect = useCallback((item) => {
+        const idx = STARTUP_SCAN_OPTIONS.findIndex(m => m.value === item.value);
+        if (idx >= 0)
+            setStartupScanIdx(idx);
+        setStep('automation');
+    }, []);
+    const handleAutomationSelect = useCallback((item) => {
+        const idx = AUTOMATION_LEVELS.findIndex(m => m.value === item.value);
+        if (idx >= 0)
+            setAutomationIdx(idx);
+        setStep('github-comments');
+    }, []);
+    const handleGitHubCommentSelect = useCallback((item) => {
+        const idx = GITHUB_COMMENT_OPTIONS.findIndex(m => m.value === item.value);
+        if (idx >= 0)
+            setGitHubCommentIdx(idx);
+        setStep('done');
+    }, []);
+    const handleDoneSelect = useCallback((item) => {
+        if (item.value === 'discard') {
+            onExit();
+            if (flow !== 'reconfigure')
+                exit();
+            return;
+        }
+        const draft = buildDraft();
+        if (draft.repos.length === 0) {
+            setLoading('Select at least one repository before saving.');
+            setTimeout(() => setLoading(''), 2000);
+            return;
+        }
+        const yaml = buildConfigYaml();
+        const action = item.value === 'start'
+            ? 'start'
+            : item.value === 'save'
+                ? 'save'
+                : 'exit';
+        onComplete({ action, yaml, draft });
+        if (flow !== 'reconfigure')
+            exit();
+    }, [buildConfigYaml, buildDraft, exit, flow, onComplete, onExit]);
+    // ── Step tracking ────────────────────────────────────────────────
+    const allSteps = ['env', 'scope-select', 'agent-default', 'run-mode', 'trigger-mode', 'startup-scan', 'automation', 'github-comments', 'done'];
+    const stepLabels = ['Environment', 'Repos', 'Agent', 'Mode', 'Trigger', 'Startup', 'Automation', 'GitHub', 'Confirm'];
+    const currentMainStep = allSteps.indexOf(['scope-mode', 'repo-select'].includes(step) ? 'scope-select'
+        : step === 'agent-mentions' ? 'agent-default'
+            : step);
+    const selectedScopes = scopeTargets.filter(target => target.selected);
+    const useBigText = termWidth >= 80;
+    return (React.createElement(Box, { flexDirection: "column", paddingX: 1 },
+        React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, useBigText ? (React.createElement(BigText, { text: "Symphony", font: "chrome", colors: [gradient.blue6, gradient.blue3] })) : (React.createElement(Box, null, GradientText({ text: 'Symphony GitHub', from: gradient.blue6, to: gradient.blue2, bold: true })))),
+        React.createElement(Box, { paddingX: 2, marginBottom: 0 },
+            React.createElement(Text, { color: colors.primary }, progressBar(currentMainStep, allSteps.length - 1, 30)),
+            React.createElement(Text, { color: colors.muted },
+                " ",
+                Math.round((currentMainStep / (allSteps.length - 1)) * 100),
+                "%")),
+        React.createElement(Box, { paddingX: 2, marginBottom: 1 }, stepLabels.map((label, idx) => (React.createElement(React.Fragment, { key: label },
+            idx > 0 && React.createElement(Text, { color: colors.border },
+                " ",
+                '>',
+                " "),
+            React.createElement(Text, { color: idx === currentMainStep ? colors.primaryLight : idx < currentMainStep ? colors.success : colors.muted, bold: idx === currentMainStep },
+                idx < currentMainStep ? '\u2713 ' : '',
+                label))))),
+        loading && (React.createElement(Box, { paddingX: 2 },
+            React.createElement(Text, { color: colors.warning },
+                React.createElement(Spinner, { type: "dots" }),
+                " ",
+                loading))),
+        step === 'env' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "Environment"),
+            React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                envChecks.length === 0 && React.createElement(Text, { color: colors.muted },
+                    React.createElement(Spinner, { type: "dots" }),
+                    " Checking..."),
+                envChecks.map(check => (React.createElement(Text, { key: check.name },
+                    React.createElement(Text, { color: check.ok ? colors.success : colors.muted }, check.ok ? ' \u2713 ' : ' \u25CB '),
+                    React.createElement(Text, { color: check.ok ? colors.text : colors.muted }, check.name),
+                    check.detail && React.createElement(Text, { color: colors.muted },
+                        " ",
+                        check.detail))))),
+            envDone && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted }, "Press "),
+                React.createElement(Text, { color: colors.key }, "Enter"),
+                React.createElement(Text, { color: colors.muted }, " to continue"))))),
+        step === 'scope-select' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "Select GitHub accounts and organizations"),
+            React.createElement(Text, { color: colors.muted }, "Space to toggle. Enter includes all repos by default; manual selection is optional."),
+            selectedScopes.length > 0 && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.success },
+                    "Selected: ",
+                    selectedScopes.length))),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" }, scopeTargets.map((target, idx) => {
+                const isSelected = target.selected;
+                const isFocused = idx === scopeIdx;
+                return (React.createElement(Text, { key: target.login, color: isFocused ? colors.primaryLight : colors.text, bold: isFocused },
+                    isFocused ? ' ▸ ' : '   ',
+                    React.createElement(Text, { color: isSelected ? colors.success : colors.muted },
+                        "[",
+                        isSelected ? 'x' : ' ',
+                        "]"),
+                    ' ',
+                    targetLabel(target)));
+            })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "\u2191\u2193"),
+                    " move  ",
+                    ' ',
+                    React.createElement(Text, { color: colors.key }, "Space"),
+                    " toggle  ",
+                    React.createElement(Text, { color: colors.key }, "Enter"),
+                    " all repos  ",
+                    React.createElement(Text, { color: colors.key }, "m"),
+                    " manual  ",
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'scope-mode' && currentTarget && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text },
+                "Repository scope for ",
+                targetLabel(currentTarget)),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: SCOPE_OPTIONS.map(o => ({ label: `${o.label} - ${o.desc}`, value: o.value })), initialIndex: currentTarget.watchAll ? 0 : 1, onSelect: handleScopeModeSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'scope-mode' })),
+            currentTarget.reposLoaded && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { color: colors.muted },
+                    "Loaded: ",
+                    currentTarget.repos.length,
+                    " repos"),
+                React.createElement(Text, { color: colors.muted },
+                    "Selected: ",
+                    currentTarget.repos.filter(r => r.selected).length))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'repo-select' && currentTarget && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text },
+                "Choose repositories for ",
+                targetLabel(currentTarget)),
+            repoSearchActive ? (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.key }, "Search: "),
+                React.createElement(Text, { color: colors.text },
+                    repoSearch,
+                    React.createElement(Text, { color: colors.primaryLight }, "_")))) : repoSearch ? (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    "Filter: ",
+                    repoSearch))) : null,
+            React.createElement(Box, { flexDirection: "column", marginTop: 1, height: Math.min(Math.max(filteredRepos.length, 1), 20) }, filteredRepos.length === 0 ? (React.createElement(Text, { color: colors.muted }, "No repositories match the current filter.")) : filteredRepos.slice(Math.max(0, repoIdx - 15), Math.max(0, repoIdx - 15) + 20).map((repo, idx) => {
+                const actualIdx = Math.max(0, repoIdx - 15) + idx;
+                return (React.createElement(Text, { key: repo.name, color: actualIdx === repoIdx ? colors.primaryLight : colors.text, bold: actualIdx === repoIdx },
+                    actualIdx === repoIdx ? ' \u25B8' : '  ',
+                    " [",
+                    repo.selected ? 'x' : ' ',
+                    "] ",
+                    repo.name));
+            })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.success },
+                    "Selected: ",
+                    currentTarget.repos.filter(r => r.selected).length)),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Space"),
+                    " toggle  ",
+                    React.createElement(Text, { color: colors.key }, "a"),
+                    " all  ",
+                    React.createElement(Text, { color: colors.key }, "/"),
+                    " search  ",
+                    React.createElement(Text, { color: colors.key }, "Enter"),
+                    " continue  ",
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'agent-default' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "Choose the default agent for @agent"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: installedAgents.map(a => ({ label: a, value: a })), initialIndex: Math.max(0, installedAgents.findIndex(agent => agent === defaultAgent)), onSelect: handleAgentSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'agent-default' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'agent-mentions' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "Default mention aliases"),
+            React.createElement(Text, { color: colors.muted }, "Press Enter to keep these, or edit any alias."),
+            mentionEditActive ? (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.key }, "Mention: "),
+                React.createElement(Text, { color: colors.text },
+                    mentionInput,
+                    React.createElement(Text, { color: colors.primaryLight }, "_")))) : (React.createElement(Box, { flexDirection: "column", marginTop: 1 }, mentionItems.map((item, idx) => (React.createElement(Text, { key: `${item.agent}-${idx}`, color: idx === mentionIdx ? colors.primaryLight : colors.text, bold: idx === mentionIdx },
+                idx === mentionIdx ? ' \u25B8 ' : '   ',
+                item.mention,
+                " ",
+                React.createElement(Text, { color: colors.muted },
+                    "-> ",
+                    item.agent)))))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted }, mentionEditActive ? (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: colors.key }, "Enter"),
+                    " save  ",
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " cancel")) : (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: colors.key }, '\u2191\u2193'),
+                    " navigate  ",
+                    React.createElement(Text, { color: colors.key }, "e"),
+                    " edit  ",
+                    React.createElement(Text, { color: colors.key }, "r"),
+                    " reset  ",
+                    React.createElement(Text, { color: colors.key }, "Enter"),
+                    " continue  ",
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))))),
+        step === 'run-mode' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "How should runs be handled by default?"),
+            React.createElement(Text, { color: colors.muted }, "This selects PR merge behavior only. Swarm / Director auto-evolution is configured separately in `swarm` after onboarding."),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: RUN_MODES.map(m => ({ label: `${m.label} - ${m.desc}`, value: m.value })), initialIndex: runModeIdx, onSelect: handleRunModeSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'run-mode' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'trigger-mode' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "When should agents trigger?"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: TRIGGER_MODES.map(m => ({ label: `${m.label} - ${m.desc}`, value: m.value })), initialIndex: triggerModeIdx, onSelect: handleTriggerSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'trigger-mode' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'automation' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "Automation level"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: AUTOMATION_LEVELS.map(m => ({ label: `${m.label} - ${m.desc}`, value: m.value })), initialIndex: automationIdx, onSelect: handleAutomationSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'automation' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'github-comments' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "GitHub progress comments"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: GITHUB_COMMENT_OPTIONS.map(option => ({ label: `${option.label} - ${option.desc}`, value: option.value })), initialIndex: githubCommentIdx, onSelect: handleGitHubCommentSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'github-comments' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted }, "This controls whether Symphony mirrors agent progress, terminal traces, and the final result back into issue and PR comments.")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'startup-scan' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, "Existing open issues on startup"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: STARTUP_SCAN_OPTIONS.map(option => ({ label: `${option.label} - ${option.desc}`, value: option.value })), initialIndex: startupScanIdx, onSelect: handleStartupScanSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'startup-scan' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted }, "When enabled, Symphony caches the last startup scan and only rechecks issues/comments updated since then.")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back")))),
+        step === 'done' && (React.createElement(Box, { flexDirection: "column", paddingX: 2 },
+            React.createElement(Text, { bold: true, color: colors.text }, flow === 'reconfigure' ? 'Ready to apply changes' : 'Ready to write config'),
+            React.createElement(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: colors.border, paddingX: 1, paddingY: 0 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Owners:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, selectedScopes.length > 0 ? selectedScopes.map(t => t.login).join(', ') : '(none)')),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Repos:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, selectedRepos.length)),
+                selectedScopes.map(target => (React.createElement(Box, { key: target.login },
+                    React.createElement(Text, { color: colors.muted }, `${target.login}:`.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, target.watchAll ? `all ${target.repos.length} repos` : `${target.repos.filter(r => r.selected).length} selected`)))),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Default agent:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.accent, bold: true }, defaultAgent)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Mentions:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, uniqueMentions.map(i => `${i.mention} -> ${i.agent}`).join(', '))),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Mode:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, RUN_MODES[runModeIdx].label)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Trigger:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, TRIGGER_MODES[triggerModeIdx].label)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Startup scan:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, STARTUP_SCAN_OPTIONS[startupScanIdx].label)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Automation:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, AUTOMATION_LEVELS[automationIdx].label)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'GitHub notes:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, GITHUB_COMMENT_OPTIONS[githubCommentIdx].label)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Poll:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text },
+                        DEFAULT_POLL_INTERVAL_SEC,
+                        "s")),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: colors.muted }, 'Path:'.padEnd(14)),
+                    React.createElement(Text, { color: colors.text }, configPath))),
+            React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, { bold: true, color: colors.text }, "What next?"),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(SelectInput, { items: flow === 'reconfigure'
+                            ? [
+                                { label: 'Apply changes', value: 'save' },
+                                { label: 'Cancel without saving', value: 'discard' },
+                            ]
+                            : [
+                                { label: 'Start Symphony now', value: 'start' },
+                                { label: 'Exit (write config only)', value: 'exit' },
+                            ], onSelect: handleDoneSelect, indicatorComponent: SelectIndicator, itemComponent: SelectItem, isFocused: step === 'done' }))),
+            flow !== 'reconfigure' && process.env.TMUX && doneIdx === 0 && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted }, "Will create a new tmux session and switch to it."))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: colors.muted },
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " back"))))));
+};
+//# sourceMappingURL=Onboarding.js.map