viberag 0.1.0

package/dist/cli/components/CleanWizard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Clean Wizard Component
+ *
+ * Interactive wizard for cleaning up VibeRAG from a project,
+ * including MCP server configurations.
+ */
+import React from 'react';
+type Props = {
+    projectRoot: string;
+    viberagDir: string;
+    onComplete: () => void;
+    onCancel: () => void;
+    /** For outputting status messages */
+    addOutput: (type: 'system' | 'user', content: string) => void;
+};
+export declare function CleanWizard({ projectRoot, viberagDir, onComplete, onCancel, addOutput, }: Props): React.ReactElement;
+export default CleanWizard;

package/dist/cli/components/CleanWizard.js

@@ -0,0 +1,169 @@
+/**
+ * Clean Wizard Component
+ *
+ * Interactive wizard for cleaning up VibeRAG from a project,
+ * including MCP server configurations.
+ */
+import React, { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { EDITORS } from '../data/mcp-editors.js';
+import { findConfiguredEditors, removeViberagConfig, } from '../commands/mcp-setup.js';
+const CONFIRM_ITEMS = [
+    { label: 'Yes, remove everything', value: 'continue' },
+    { label: 'Cancel', value: 'cancel' },
+];
+const MCP_CLEANUP_ITEMS = [
+    { label: 'Yes, remove from MCP configs too (Recommended)', value: 'yes' },
+    { label: 'No, keep MCP configurations', value: 'no' },
+];
+export function CleanWizard({ projectRoot, viberagDir, onComplete, onCancel, addOutput, }) {
+    const [step, setStep] = useState('confirm');
+    const [projectScopeEditors, setProjectScopeEditors] = useState([]);
+    const [globalScopeEditors, setGlobalScopeEditors] = useState([]);
+    const [mcpResults, setMcpResults] = useState([]);
+    const [viberagRemoved, setViberagRemoved] = useState(false);
+    // Handle Escape to cancel
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel();
+        }
+    });
+    // Find configured editors on mount
+    useEffect(() => {
+        findConfiguredEditors(projectRoot).then(({ projectScope, globalScope }) => {
+            setProjectScopeEditors(projectScope);
+            setGlobalScopeEditors(globalScope);
+        });
+    }, [projectRoot]);
+    // Handle confirmation
+    const handleConfirm = useCallback((action) => {
+        if (action === 'cancel') {
+            onCancel();
+            return;
+        }
+        // If there are project-scope MCP configs, ask about cleanup
+        if (projectScopeEditors.length > 0) {
+            setStep('mcp-cleanup');
+        }
+        else {
+            // No MCP configs to clean, go straight to processing
+            setStep('processing');
+            performCleanup(false);
+        }
+    }, [projectScopeEditors, onCancel]);
+    // Perform the actual cleanup
+    const performCleanup = useCallback(async (cleanMcp) => {
+        const fs = await import('node:fs/promises');
+        // Remove .viberag directory
+        try {
+            await fs.rm(viberagDir, { recursive: true, force: true });
+            setViberagRemoved(true);
+        }
+        catch (error) {
+            addOutput('system', `Failed to remove ${viberagDir}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Clean MCP configs if requested
+        if (cleanMcp) {
+            const results = [];
+            for (const editor of projectScopeEditors) {
+                const result = await removeViberagConfig(editor, projectRoot);
+                results.push(result);
+            }
+            setMcpResults(results);
+        }
+        setStep('summary');
+    }, [viberagDir, projectScopeEditors, projectRoot, addOutput]);
+    // Handle MCP cleanup choice
+    const handleMcpCleanup = useCallback((action) => {
+        setStep('processing');
+        performCleanup(action === 'yes');
+    }, [performCleanup]);
+    // Step: Confirm
+    if (step === 'confirm') {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "Clean VibeRAG"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null, "This will remove:"),
+                React.createElement(Text, { dimColor: true },
+                    " \u2022 ",
+                    viberagDir,
+                    "/ (index and config)"),
+                projectScopeEditors.length > 0 && (React.createElement(Text, { dimColor: true },
+                    ' ',
+                    "\u2022 MCP configs (",
+                    projectScopeEditors.map(e => e.name).join(', '),
+                    ")"))),
+            globalScopeEditors.length > 0 && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "blue" },
+                    "Note: Global MCP configs (",
+                    globalScopeEditors.map(e => e.name).join(', '),
+                    ")",
+                    '\n',
+                    "will NOT be modified. Remove manually if needed."))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: CONFIRM_ITEMS, onSelect: item => handleConfirm(item.value) })),
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel")));
+    }
+    // Step: MCP Cleanup choice
+    if (step === 'mcp-cleanup') {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "Remove from MCP configs?"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null, "Found viberag in these project MCP configs:"),
+                projectScopeEditors.map(editor => (React.createElement(Text, { key: editor.id, dimColor: true },
+                    ' ',
+                    "\u2022 ",
+                    editor.name,
+                    " (",
+                    editor.configPath,
+                    ")")))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: MCP_CLEANUP_ITEMS, onSelect: item => handleMcpCleanup(item.value) })),
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel")));
+    }
+    // Step: Processing
+    if (step === 'processing') {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "Cleaning..."),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Removing VibeRAG from project..."))));
+    }
+    // Step: Summary
+    if (step === 'summary') {
+        const successfulRemovals = mcpResults.filter(r => r.success);
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Clean Complete"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                viberagRemoved && (React.createElement(Text, null,
+                    React.createElement(Text, { color: "green" }, "\u2713"),
+                    " Removed ",
+                    viberagDir,
+                    "/")),
+                successfulRemovals.map(r => {
+                    const editor = EDITORS.find(e => e.id === r.editor);
+                    return (React.createElement(Text, { key: r.editor },
+                        React.createElement(Text, { color: "green" }, "\u2713"),
+                        " ",
+                        editor?.name ?? r.editor,
+                        React.createElement(Text, { dimColor: true },
+                            " Updated ",
+                            r.configPath)));
+                })),
+            globalScopeEditors.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { bold: true, color: "blue" }, "Manual cleanup needed:"),
+                globalScopeEditors.map(editor => (React.createElement(Text, { key: editor.id, dimColor: true },
+                    "\u2022 ",
+                    editor.name,
+                    ": Remove \"viberag\" from ",
+                    editor.configPath))))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Run /init to reinitialize VibeRAG.")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: [{ label: 'Done', value: 'done' }], onSelect: () => onComplete() }))));
+    }
+    // Fallback
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { color: "red" }, "Unknown wizard step")));
+}
+export default CleanWizard;

package/dist/cli/components/InitWizard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Multi-step initialization wizard component.
+ * Guides users through embedding provider selection and API key configuration.
+ */
+import React from 'react';
+import type { InitWizardConfig, EmbeddingProviderType } from '../../common/types.js';
+type Props = {
+    step: number;
+    config: Partial<InitWizardConfig>;
+    isReinit: boolean;
+    /** Existing API key from previous config (for reinit flow) */
+    existingApiKey?: string;
+    /** Existing provider from previous config (for reinit flow) */
+    existingProvider?: EmbeddingProviderType;
+    onStepChange: (step: number, data?: Partial<InitWizardConfig>) => void;
+    onComplete: (config: InitWizardConfig) => void;
+    onCancel: () => void;
+};
+export declare function InitWizard({ step, config, isReinit, existingApiKey, existingProvider, onStepChange, onComplete, onCancel, }: Props): React.ReactElement;
+export default InitWizard;

package/dist/cli/components/InitWizard.js

@@ -0,0 +1,370 @@
+/**
+ * Multi-step initialization wizard component.
+ * Guides users through embedding provider selection and API key configuration.
+ */
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+/**
+ * Cloud providers that require API keys.
+ */
+const CLOUD_PROVIDERS = ['gemini', 'mistral', 'openai'];
+function isCloudProvider(provider) {
+    return CLOUD_PROVIDERS.includes(provider);
+}
+/**
+ * URLs to get API keys for each cloud provider.
+ */
+const API_KEY_URLS = {
+    gemini: 'https://aistudio.google.com',
+    mistral: 'https://console.mistral.ai/api-keys/',
+    openai: 'https://platform.openai.com/api-keys',
+};
+/**
+ * Provider configurations with specs and pricing.
+ */
+const PROVIDER_CONFIG = {
+    local: {
+        name: 'Local',
+        model: 'Qwen3-0.6B Q8',
+        modelFull: 'Qwen/Qwen3-Embedding-0.6B',
+        dims: '1024',
+        context: '32K',
+        cost: 'Free',
+        note: '~700MB download, ~1.2GB RAM',
+        description: 'Offline, no API key needed',
+    },
+    'local-4b': {
+        name: 'Local 4B',
+        model: 'Qwen3-4B FP32',
+        modelFull: 'Qwen/Qwen3-Embedding-4B',
+        dims: '2560',
+        context: '32K',
+        cost: 'Free',
+        note: '~8GB download, ~8GB RAM',
+        description: 'Offline, better quality (+5 MTEB)',
+    },
+    gemini: {
+        name: 'Gemini',
+        model: 'gemini-embedding-001',
+        modelFull: 'gemini-embedding-001',
+        dims: '768',
+        context: '2K',
+        cost: 'Free tier',
+        note: 'API key required',
+        description: 'Fast API, free tier available',
+    },
+    mistral: {
+        name: 'Mistral',
+        model: 'codestral-embed',
+        modelFull: 'codestral-embed',
+        dims: '1024',
+        context: '8K',
+        cost: '$0.10/1M',
+        note: 'API key required',
+        description: 'Code-optimized embeddings',
+    },
+    openai: {
+        name: 'OpenAI',
+        model: 'text-embed-3-sm',
+        modelFull: 'text-embedding-3-small',
+        dims: '1536',
+        context: '8K',
+        cost: '$0.02/1M',
+        note: 'API key required',
+        description: 'Fast and reliable API',
+    },
+};
+// Simple provider options for selection
+// Note: local-4b exists in code but hidden from UI - no transformers.js-compatible ONNX available yet
+const PROVIDER_ITEMS = [
+    { label: 'Local     - Qwen3-0.6B Q8 (~700MB, ~1.2GB RAM)', value: 'local' },
+    // {label: 'Local 4B  - Qwen3-4B FP32 (~8GB, ~8GB RAM)', value: 'local-4b'}, // No ONNX available
+    { label: 'Gemini    - gemini-embedding-001 (Free tier)', value: 'gemini' },
+    { label: 'Mistral   - codestral-embed', value: 'mistral' },
+    { label: 'OpenAI    - text-embedding-3-small', value: 'openai' },
+];
+/**
+ * Local model info.
+ * Note: 4B not shown - no transformers.js-compatible ONNX available yet
+ */
+const LOCAL_MODELS_DATA = [
+    { Model: 'Qwen3-0.6B', Quant: 'Q8', Download: '~700MB', RAM: '~1.2GB' },
+];
+/**
+ * Frontier/API models - fastest, best quality.
+ */
+const FRONTIER_MODELS_DATA = [
+    {
+        Provider: 'Gemini',
+        Model: 'gemini-embedding-001',
+        Dims: '768',
+        Cost: 'Free tier',
+    },
+    {
+        Provider: 'Mistral',
+        Model: 'codestral-embed',
+        Dims: '1024',
+        Cost: '$0.10/1M',
+    },
+    {
+        Provider: 'OpenAI',
+        Model: 'text-embed-3-small',
+        Dims: '1536',
+        Cost: '$0.02/1M',
+    },
+];
+function SimpleTable({ data, columns, }) {
+    const dataRow = (row, isHeader = false) => {
+        const cells = columns.map(col => {
+            const value = row[col.key] ?? '';
+            return ' ' + value.padEnd(col.width - 1);
+        });
+        return (React.createElement(Text, { bold: isHeader, color: isHeader ? 'cyan' : undefined }, '│' + cells.join('│') + '│'));
+    };
+    // Header row from column keys
+    const headerRow = {};
+    for (const col of columns) {
+        headerRow[col.key] = col.key;
+    }
+    return (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+        React.createElement(Text, null, '┌' + columns.map(col => '─'.repeat(col.width)).join('┬') + '┐'),
+        dataRow(headerRow, true),
+        React.createElement(Text, null, '├' + columns.map(col => '─'.repeat(col.width)).join('┼') + '┤'),
+        data.map((row, i) => (React.createElement(React.Fragment, { key: i }, dataRow(row)))),
+        React.createElement(Text, null, '└' + columns.map(col => '─'.repeat(col.width)).join('┴') + '┘')));
+}
+/**
+ * Comparison table component showing local and frontier models.
+ */
+function ComparisonTable() {
+    const localColumns = [
+        { key: 'Model', width: 12 },
+        { key: 'Quant', width: 6 },
+        { key: 'Download', width: 10 },
+        { key: 'RAM', width: 8 },
+    ];
+    const frontierColumns = [
+        { key: 'Provider', width: 10 },
+        { key: 'Model', width: 20 },
+        { key: 'Dims', width: 6 },
+        { key: 'Cost', width: 11 },
+    ];
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "Local Models"),
+            React.createElement(Text, { dimColor: true }, " - Offline, Slower, Free")),
+        React.createElement(SimpleTable, { data: LOCAL_MODELS_DATA, columns: localColumns }),
+        React.createElement(Text, { dimColor: true, italic: true }, "* Initial indexing may take time. Future updates are incremental."),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Frontier Models"),
+            React.createElement(Text, { dimColor: true }, " - Fastest, Best Quality")),
+        React.createElement(SimpleTable, { data: FRONTIER_MODELS_DATA, columns: frontierColumns })));
+}
+// Reinit confirmation options
+const REINIT_ITEMS = [
+    { label: 'Continue (reinitialize)', value: 'continue' },
+    { label: 'Cancel', value: 'cancel' },
+];
+// Final confirmation options
+const CONFIRM_ITEMS = [
+    { label: 'Initialize', value: 'init' },
+    { label: 'Cancel', value: 'cancel' },
+];
+// API key action options for reinit
+const API_KEY_ACTION_ITEMS = [
+    { label: 'Keep existing API key', value: 'keep' },
+    { label: 'Enter new API key', value: 'new' },
+];
+/**
+ * Simple text input component for API key entry.
+ */
+function ApiKeyInputStep({ providerName, apiKeyInput, setApiKeyInput, onSubmit, }) {
+    // Handle text input (supports paste)
+    useInput((input, key) => {
+        if (key.return) {
+            onSubmit(apiKeyInput);
+        }
+        else if (key.backspace || key.delete) {
+            setApiKeyInput(apiKeyInput.slice(0, -1));
+        }
+        else if (!key.ctrl && !key.meta && input) {
+            // Add printable characters (supports multi-char paste)
+            setApiKeyInput(apiKeyInput + input);
+        }
+    });
+    return (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+        React.createElement(Text, null,
+            "Enter your ",
+            providerName,
+            " API key:"),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "blue" }, "> "),
+            React.createElement(Text, null, apiKeyInput),
+            React.createElement(Text, { color: "gray" }, "\u2588")),
+        apiKeyInput.trim() === '' && (React.createElement(Text, { color: "yellow", dimColor: true }, "API key is required")),
+        React.createElement(Text, { dimColor: true }, "Press Enter to continue")));
+}
+export function InitWizard({ step, config, isReinit, existingApiKey, existingProvider, onStepChange, onComplete, onCancel, }) {
+    // State for API key input
+    const [apiKeyInput, setApiKeyInput] = useState('');
+    const [apiKeyAction, setApiKeyAction] = useState(null);
+    // Handle Escape to cancel
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel();
+        }
+    });
+    // Normalize props with defensive defaults
+    const normalizedStep = typeof step === 'number' && !isNaN(step) ? step : 0;
+    const normalizedIsReinit = typeof isReinit === 'boolean' ? isReinit : false;
+    // Check if current provider is a cloud provider
+    const currentProvider = config.provider ?? 'local';
+    const needsApiKey = isCloudProvider(currentProvider);
+    // Check if we have an existing API key for the same provider
+    const hasExistingKeyForProvider = existingApiKey && existingProvider === currentProvider;
+    // Compute effective step (adjusted for non-reinit flow)
+    // Steps: 0=reinit confirm, 1=provider select, 2=api key (cloud only), 3=final confirm
+    const effectiveStep = normalizedIsReinit
+        ? normalizedStep
+        : normalizedStep + 1;
+    // Step 0 (reinit only): Confirmation
+    if (normalizedIsReinit && normalizedStep === 0) {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "yellow" }, "Viberag is already initialized"),
+            React.createElement(Text, { dimColor: true }, "This will reset your configuration and reindex the codebase."),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: REINIT_ITEMS, onSelect: item => {
+                        if (item.value === 'continue') {
+                            onStepChange(1);
+                        }
+                        else {
+                            onCancel();
+                        }
+                    } })),
+            React.createElement(Text, { dimColor: true },
+                '\n',
+                "Use arrow keys to navigate, Enter to select, Esc to cancel")));
+    }
+    // Step 1: Provider selection
+    // Fresh init: step=0 (effectiveStep=1), Reinit: step=1 (effectiveStep=1)
+    if (effectiveStep === 1) {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true }, "Choose Embedding Provider"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: PROVIDER_ITEMS, onSelect: item => {
+                        // Reset API key state when provider changes
+                        setApiKeyInput('');
+                        setApiKeyAction(null);
+                        // Use relative increment: step + 1
+                        onStepChange(normalizedStep + 1, { provider: item.value });
+                    } })),
+            React.createElement(ComparisonTable, null),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel"))));
+    }
+    // Step 2: API Key input (cloud providers only)
+    // For local providers, skip to step 3 (confirmation)
+    if (effectiveStep === 2) {
+        // Skip API key step for local providers
+        if (!needsApiKey) {
+            // Auto-advance to confirmation
+            onStepChange(normalizedStep + 1);
+            return (React.createElement(Box, null,
+                React.createElement(Text, { dimColor: true }, "Loading...")));
+        }
+        const provider = currentProvider;
+        const info = PROVIDER_CONFIG[provider];
+        const apiKeyUrl = API_KEY_URLS[provider];
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true },
+                "Configure ",
+                info.name,
+                " API Key"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null,
+                    "Get your API key:",
+                    ' ',
+                    React.createElement(Text, { color: "cyan", underline: true }, apiKeyUrl))),
+            hasExistingKeyForProvider && apiKeyAction === null ? (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { color: "green" },
+                    "An API key is already configured for ",
+                    info.name,
+                    "."),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(SelectInput, { items: API_KEY_ACTION_ITEMS, onSelect: item => {
+                            if (item.value === 'keep') {
+                                // Keep existing key, advance to confirmation
+                                onStepChange(normalizedStep + 1, { apiKey: existingApiKey });
+                            }
+                            else {
+                                // Show text input for new key
+                                setApiKeyAction('new');
+                            }
+                        } })))) : (React.createElement(ApiKeyInputStep, { providerName: info.name, apiKeyInput: apiKeyInput, setApiKeyInput: setApiKeyInput, onSubmit: key => {
+                    if (key.trim()) {
+                        onStepChange(normalizedStep + 1, { apiKey: key.trim() });
+                    }
+                } })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Esc to cancel"))));
+    }
+    // Step 3: Confirmation
+    if (effectiveStep === 3) {
+        const provider = config.provider ?? 'gemini';
+        const info = PROVIDER_CONFIG[provider];
+        const hasApiKey = !!config.apiKey;
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true }, "Ready to Initialize"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "Provider: "),
+                    React.createElement(Text, { bold: true }, info.name),
+                    React.createElement(Text, { dimColor: true },
+                        " - ",
+                        info.description)),
+                React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "Model: "),
+                    info.modelFull),
+                React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "Specs: "),
+                    info.dims,
+                    "d, ",
+                    info.context,
+                    " context"),
+                React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "Cost: "),
+                    info.cost),
+                isCloudProvider(provider) && (React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "API Key: "),
+                    hasApiKey ? (React.createElement(Text, { color: "green" }, "Configured")) : (React.createElement(Text, { color: "red" }, "Missing")))),
+                React.createElement(Text, null,
+                    React.createElement(Text, { dimColor: true }, "Directory:"),
+                    " .viberag/")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: CONFIRM_ITEMS, onSelect: item => {
+                        if (item.value === 'init') {
+                            onComplete({ provider, apiKey: config.apiKey });
+                        }
+                        else {
+                            onCancel();
+                        }
+                    } })),
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel")));
+    }
+    // Fallback (shouldn't happen)
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { color: "red" }, "Unknown wizard step"),
+        React.createElement(Text, { dimColor: true },
+            "Debug: step=",
+            step,
+            " (",
+            typeof step,
+            "), isReinit=",
+            String(isReinit),
+            " (",
+            typeof isReinit,
+            "), effectiveStep=",
+            effectiveStep)));
+}
+export default InitWizard;

package/dist/cli/components/McpSetupWizard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MCP Setup Wizard Component
+ *
+ * Multi-step wizard for configuring VibeRAG's MCP server
+ * across various AI coding tools.
+ */
+import React from 'react';
+import { type EditorId } from '../data/mcp-editors.js';
+import { type McpSetupResult } from '../commands/mcp-setup.js';
+/**
+ * Wizard step types.
+ */
+export type McpSetupStep = 'prompt' | 'select' | 'configure' | 'summary';
+/**
+ * Wizard configuration.
+ */
+export interface McpSetupWizardConfig {
+    selectedEditors: EditorId[];
+    results: McpSetupResult[];
+}
+type Props = {
+    step: McpSetupStep;
+    config: Partial<McpSetupWizardConfig>;
+    projectRoot: string;
+    /** Whether this is shown after /init (shows prompt step) */
+    showPrompt: boolean;
+    onStepChange: (step: McpSetupStep, data?: Partial<McpSetupWizardConfig>) => void;
+    onComplete: (config: McpSetupWizardConfig) => void;
+    onCancel: () => void;
+    /** For outputting instructions to console */
+    addOutput?: (type: 'system' | 'user', content: string) => void;
+};
+/**
+ * MCP Setup Wizard main component.
+ */
+export declare function McpSetupWizard({ step, config, projectRoot, showPrompt, onStepChange, onComplete, onCancel, addOutput, }: Props): React.ReactElement;
+export default McpSetupWizard;