viberag 0.1.0

package/dist/cli/components/McpSetupWizard.js

@@ -0,0 +1,387 @@
+/**
+ * MCP Setup Wizard Component
+ *
+ * Multi-step wizard for configuring VibeRAG's MCP server
+ * across various AI coding tools.
+ */
+import React, { useState, useCallback, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { EDITORS } from '../data/mcp-editors.js';
+import { writeMcpConfig, getManualInstructions, isAlreadyConfigured, addToGitignore, getProjectConfigPaths, } from '../commands/mcp-setup.js';
+/**
+ * Prompt items for post-init flow.
+ */
+const PROMPT_ITEMS = [
+    { label: 'Yes, configure now', value: 'yes' },
+    { label: 'Skip (run /mcp-setup later)', value: 'skip' },
+];
+/**
+ * Action items for each editor.
+ */
+const PROJECT_ACTION_ITEMS = [
+    { label: 'Auto-configure (Recommended)', value: 'auto' },
+    { label: 'Show manual instructions', value: 'manual' },
+    { label: 'Skip this editor', value: 'skip' },
+];
+const GLOBAL_ACTION_ITEMS = [
+    { label: 'Auto-update config (Recommended)', value: 'auto' },
+    { label: 'Show config to copy manually', value: 'manual' },
+    { label: 'Skip this editor', value: 'skip' },
+];
+const UI_ACTION_ITEMS = [
+    { label: 'Show setup instructions', value: 'manual' },
+    { label: 'Skip this editor', value: 'skip' },
+];
+/**
+ * Multi-select checkbox list component.
+ */
+function MultiSelect({ items, selected, onToggle, onSubmit, highlightIndex, onHighlightChange, disabledItems, }) {
+    useInput((input, key) => {
+        if (key.upArrow) {
+            onHighlightChange(Math.max(0, highlightIndex - 1));
+        }
+        else if (key.downArrow) {
+            onHighlightChange(Math.min(items.length - 1, highlightIndex + 1));
+        }
+        else if (input === ' ') {
+            const item = items[highlightIndex];
+            if (item && !disabledItems?.has(item.id)) {
+                onToggle(item.id);
+            }
+        }
+        else if (key.return) {
+            onSubmit();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" }, items.map((item, index) => {
+        const isSelected = selected.has(item.id);
+        const isHighlighted = index === highlightIndex;
+        const isDisabled = disabledItems?.has(item.id);
+        const checkbox = isSelected ? '[x]' : '[ ]';
+        return (React.createElement(Box, { key: item.id },
+            React.createElement(Text, { color: isDisabled ? 'gray' : isHighlighted ? 'cyan' : undefined, bold: isHighlighted, dimColor: isDisabled },
+                isHighlighted ? '> ' : '  ',
+                checkbox,
+                " ",
+                item.label,
+                React.createElement(Text, { dimColor: true },
+                    " (",
+                    item.description,
+                    ")"),
+                isDisabled ? (React.createElement(Text, { color: "yellow" }, " (already configured)")) : null)));
+    })));
+}
+/**
+ * MCP Setup Wizard main component.
+ */
+export function McpSetupWizard({ step, config, projectRoot, showPrompt, onStepChange, onComplete, onCancel, addOutput, }) {
+    // Multi-select state
+    const [selected, setSelected] = useState(new Set(config.selectedEditors ?? []));
+    const [highlightIndex, setHighlightIndex] = useState(0);
+    const [configuredEditors, setConfiguredEditors] = useState(new Set());
+    // Per-editor configuration state
+    const [currentEditorIndex, setCurrentEditorIndex] = useState(0);
+    const [results, setResults] = useState(config.results ?? []);
+    const [isProcessing, setIsProcessing] = useState(false);
+    // Gitignore prompt state
+    const [gitignoreHandled, setGitignoreHandled] = useState(false);
+    const [gitignoreAdded, setGitignoreAdded] = useState([]);
+    // Check which editors are already configured
+    useEffect(() => {
+        const checkConfigured = async () => {
+            const configured = new Set();
+            for (const editor of EDITORS) {
+                const isConfigured = await isAlreadyConfigured(editor, projectRoot);
+                if (isConfigured) {
+                    configured.add(editor.id);
+                }
+            }
+            setConfiguredEditors(configured);
+        };
+        checkConfigured();
+    }, [projectRoot]);
+    // Handle Escape to cancel
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel();
+        }
+    });
+    // Toggle selection
+    const handleToggle = useCallback((id) => {
+        setSelected(prev => {
+            const next = new Set(prev);
+            if (next.has(id)) {
+                next.delete(id);
+            }
+            else {
+                next.add(id);
+            }
+            return next;
+        });
+    }, []);
+    // Submit selection
+    const handleSubmitSelection = useCallback(() => {
+        if (selected.size === 0) {
+            onCancel();
+            return;
+        }
+        onStepChange('configure', { selectedEditors: Array.from(selected) });
+        setCurrentEditorIndex(0);
+    }, [selected, onStepChange, onCancel]);
+    // Get current editor being configured
+    const selectedEditorIds = config.selectedEditors ?? [];
+    const currentEditorId = selectedEditorIds[currentEditorIndex];
+    const currentEditor = EDITORS.find(e => e.id === currentEditorId);
+    // Handle editor action
+    const handleEditorAction = useCallback(async (action) => {
+        if (!currentEditor)
+            return;
+        setIsProcessing(true);
+        let result;
+        if (action === 'skip') {
+            result = {
+                success: false,
+                editor: currentEditor.id,
+                method: 'instructions-shown',
+                error: 'Skipped',
+            };
+        }
+        else if (action === 'manual') {
+            // Show manual instructions
+            const instructions = getManualInstructions(currentEditor, projectRoot);
+            if (addOutput) {
+                addOutput('system', instructions);
+            }
+            result = {
+                success: true,
+                editor: currentEditor.id,
+                method: 'instructions-shown',
+            };
+        }
+        else {
+            // Auto setup
+            result = await writeMcpConfig(currentEditor, projectRoot);
+        }
+        const newResults = [...results, result];
+        setResults(newResults);
+        // Move to next editor or summary
+        if (currentEditorIndex < selectedEditorIds.length - 1) {
+            setCurrentEditorIndex(currentEditorIndex + 1);
+        }
+        else {
+            onStepChange('summary', { results: newResults });
+        }
+        setIsProcessing(false);
+    }, [
+        currentEditor,
+        projectRoot,
+        results,
+        currentEditorIndex,
+        selectedEditorIds.length,
+        onStepChange,
+        addOutput,
+    ]);
+    // Build editor items for multi-select
+    const editorItems = EDITORS.map(editor => ({
+        id: editor.id,
+        label: editor.name,
+        description: editor.description,
+    }));
+    // Get project-scope configs for gitignore prompt (computed from results)
+    // NOTE: This must be before early returns to maintain consistent hook order
+    const projectConfigs = getProjectConfigPaths(results);
+    // Handle gitignore action
+    const handleGitignore = useCallback(async (action) => {
+        if (action === 'yes') {
+            const added = [];
+            for (const configPath of projectConfigs) {
+                const success = await addToGitignore(projectRoot, configPath);
+                if (success) {
+                    added.push(configPath);
+                }
+            }
+            setGitignoreAdded(added);
+        }
+        setGitignoreHandled(true);
+    }, [projectConfigs, projectRoot]);
+    // Gitignore action items
+    const gitignoreItems = [
+        { label: 'Yes, add to .gitignore (Recommended)', value: 'yes' },
+        { label: 'No, keep in version control', value: 'no' },
+    ];
+    // Step: Prompt (post-init)
+    if (step === 'prompt' && showPrompt) {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Setup Complete"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null,
+                    "Would you like to configure an AI coding tool to use",
+                    '\n',
+                    "VibeRAG's MCP server?")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: PROMPT_ITEMS, onSelect: item => {
+                        if (item.value === 'yes') {
+                            onStepChange('select');
+                        }
+                        else {
+                            onCancel();
+                        }
+                    } })),
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel")));
+    }
+    // Step: Multi-select editors
+    if (step === 'select') {
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true }, "MCP Setup Wizard"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null,
+                    "Select AI coding tool(s) to configure:",
+                    '\n',
+                    React.createElement(Text, { dimColor: true }, "(Space to toggle, Enter to confirm)"))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(MultiSelect, { items: editorItems, selected: selected, onToggle: handleToggle, onSubmit: handleSubmitSelection, highlightIndex: highlightIndex, onHighlightChange: setHighlightIndex, disabledItems: configuredEditors })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    selected.size,
+                    " selected | \u2191/\u2193 move, Space toggle, Enter confirm, Esc cancel"))));
+    }
+    // Step: Configure each editor
+    if (step === 'configure' && currentEditor) {
+        if (isProcessing) {
+            return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+                React.createElement(Text, { bold: true },
+                    currentEditor.name,
+                    " MCP Setup"),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { color: "yellow" }, "Processing..."))));
+        }
+        const actionItems = currentEditor.scope === 'ui'
+            ? UI_ACTION_ITEMS
+            : currentEditor.scope === 'global'
+                ? GLOBAL_ACTION_ITEMS
+                : PROJECT_ACTION_ITEMS;
+        const configPathDisplay = currentEditor.scope === 'project'
+            ? currentEditor.configPath
+            : currentEditor.scope === 'global'
+                ? `${currentEditor.configPath}`
+                : 'IDE Settings';
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true },
+                currentEditor.name,
+                " MCP Setup (",
+                currentEditorIndex + 1,
+                "/",
+                selectedEditorIds.length,
+                ")"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" }, currentEditor.scope === 'project' ? (React.createElement(Text, null,
+                "VibeRAG can create or update",
+                ' ',
+                React.createElement(Text, { color: "cyan" }, configPathDisplay),
+                " automatically.")) : currentEditor.scope === 'global' ? (React.createElement(Text, null,
+                currentEditor.name,
+                " uses a global config at:",
+                '\n',
+                React.createElement(Text, { color: "cyan" }, configPathDisplay))) : (React.createElement(Text, null,
+                currentEditor.name,
+                " requires manual configuration in the IDE."))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: actionItems, onSelect: item => {
+                        handleEditorAction(item.value);
+                    } })),
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 navigate, Enter select, Esc cancel")));
+    }
+    // Step: Summary
+    if (step === 'summary') {
+        const successResults = results.filter(r => r.success && r.method !== 'instructions-shown');
+        const instructionResults = results.filter(r => r.success && r.method === 'instructions-shown');
+        const skippedResults = results.filter(r => !r.success);
+        // Show gitignore prompt if we have project configs and haven't handled yet
+        if (projectConfigs.length > 0 && !gitignoreHandled) {
+            return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+                React.createElement(Text, { bold: true, color: "yellow" }, "Add MCP configs to .gitignore?"),
+                React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                    React.createElement(Text, null, "These project-local MCP config files were created:"),
+                    projectConfigs.map(p => (React.createElement(Text, { key: p, dimColor: true },
+                        '  ',
+                        p)))),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { dimColor: true }, "MCP configs are typically machine-specific and should not be committed.")),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(SelectInput, { items: gitignoreItems, onSelect: item => handleGitignore(item.value) }))));
+        }
+        return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "MCP Setup Complete"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                successResults.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 },
+                            ' ',
+                            r.method === 'file-created'
+                                ? `Created ${r.configPath}`
+                                : r.method === 'file-merged'
+                                    ? `Updated ${r.configPath}`
+                                    : 'CLI command')));
+                }),
+                instructionResults.map(r => {
+                    const editor = EDITORS.find(e => e.id === r.editor);
+                    return (React.createElement(Text, { key: r.editor },
+                        React.createElement(Text, { color: "blue" }, "\u2139"),
+                        " ",
+                        editor?.name ?? r.editor,
+                        React.createElement(Text, { dimColor: true }, " Instructions shown above")));
+                }),
+                skippedResults.map(r => {
+                    const editor = EDITORS.find(e => e.id === r.editor);
+                    return (React.createElement(Text, { key: r.editor },
+                        React.createElement(Text, { color: "gray" }, "-"),
+                        " ",
+                        editor?.name ?? r.editor,
+                        React.createElement(Text, { dimColor: true }, " Skipped")));
+                })),
+            gitignoreAdded.length > 0 && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "green" }, "\u2713"),
+                React.createElement(Text, { dimColor: true },
+                    ' ',
+                    "Added to .gitignore: ",
+                    gitignoreAdded.join(', ')))),
+            successResults.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { bold: true }, "Verify setup:"),
+                successResults.map(r => {
+                    const editor = EDITORS.find(e => e.id === r.editor);
+                    if (!editor)
+                        return null;
+                    return (React.createElement(Box, { key: r.editor, flexDirection: "column" },
+                        React.createElement(Text, null,
+                            React.createElement(Text, { color: "cyan" },
+                                editor.name,
+                                ":"),
+                            ' ',
+                            editor.verificationSteps[0])));
+                }))),
+            successResults.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { bold: true }, "Next steps:"),
+                React.createElement(Text, null, "1. Restart your editor(s) to load the MCP server"),
+                React.createElement(Text, null, "2. Verify using the steps above"),
+                React.createElement(Text, null, "3. Test codebase_search with a code query"))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Run /mcp-setup anytime to configure more editors.")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: [{ label: 'Done', value: 'done' }], onSelect: () => {
+                        onComplete({
+                            selectedEditors: selectedEditorIds,
+                            results,
+                        });
+                    } }))));
+    }
+    // Fallback
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { color: "red" },
+            "Unknown wizard step: ",
+            step)));
+}
+export default McpSetupWizard;

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

@@ -0,0 +1,13 @@
+/**
+ * Search results display component with syntax highlighting.
+ */
+import React from 'react';
+import type { SearchResultsData } from '../../common/types.js';
+type Props = {
+    data: SearchResultsData;
+};
+/**
+ * Search results display component.
+ */
+export default function SearchResultsDisplay({ data }: Props): React.JSX.Element;
+export {};

package/dist/cli/components/SearchResultsDisplay.js

@@ -0,0 +1,130 @@
+/**
+ * Search results display component with syntax highlighting.
+ */
+import React from 'react';
+import { Box, Text, useStdout } from 'ink';
+import { highlight } from 'cli-highlight';
+/**
+ * Color mapping for chunk types.
+ */
+const TYPE_COLORS = {
+    function: 'cyan',
+    class: 'magenta',
+    method: 'blue',
+    module: 'gray',
+};
+/**
+ * Extension to language mapping for syntax highlighting.
+ */
+const EXT_TO_LANG = {
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    rs: 'rust',
+    go: 'go',
+    java: 'java',
+};
+/**
+ * Get language from filepath for syntax highlighting.
+ */
+function getLanguage(filepath) {
+    const ext = filepath.split('.').pop()?.toLowerCase() ?? '';
+    return EXT_TO_LANG[ext] ?? 'plaintext';
+}
+/**
+ * Get score color based on value.
+ */
+function getScoreColor(score) {
+    if (score > 0.8)
+        return 'green';
+    if (score > 0.5)
+        return 'yellow';
+    return 'red';
+}
+/**
+ * Truncate and format code snippet for display.
+ */
+function formatSnippet(text, filepath, maxWidth, maxLines = 4) {
+    const language = getLanguage(filepath);
+    const lines = text.split('\n').slice(0, maxLines);
+    // Truncate each line to max width
+    const truncatedLines = lines.map(line => {
+        if (line.length > maxWidth - 4) {
+            return line.slice(0, maxWidth - 7) + '...';
+        }
+        return line;
+    });
+    const truncated = truncatedLines.join('\n');
+    // Try to syntax highlight
+    try {
+        return highlight(truncated, { language, ignoreIllegals: true });
+    }
+    catch {
+        return truncated;
+    }
+}
+/**
+ * Single search result component.
+ */
+function SearchResult({ result, maxWidth, }) {
+    const typeColor = TYPE_COLORS[result.type] ?? 'white';
+    const scoreColor = getScoreColor(result.score);
+    // Format snippet with syntax highlighting
+    const snippet = formatSnippet(result.text, result.filepath, maxWidth);
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+        React.createElement(Box, null,
+            React.createElement(Text, { color: typeColor },
+                "[",
+                result.type,
+                "]"),
+            result.name && React.createElement(Text, null,
+                " ",
+                result.name)),
+        React.createElement(Box, null,
+            React.createElement(Text, null, " "),
+            React.createElement(Text, { color: "green" }, result.filepath),
+            React.createElement(Text, { dimColor: true },
+                ":",
+                result.startLine,
+                "-",
+                result.endLine)),
+        React.createElement(Box, null,
+            React.createElement(Text, null, " Score: "),
+            React.createElement(Text, { color: scoreColor }, result.score.toFixed(4))),
+        React.createElement(Box, { marginLeft: 1, marginTop: 0 },
+            React.createElement(Text, null, snippet))));
+}
+/**
+ * Search results display component.
+ */
+export default function SearchResultsDisplay({ data }) {
+    const { stdout } = useStdout();
+    const terminalWidth = stdout?.columns ?? 80;
+    const maxSnippetWidth = Math.min(terminalWidth - 4, 176);
+    if (data.results.length === 0) {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { dimColor: true },
+                "No results found for \"",
+                data.query,
+                "\" (",
+                data.elapsedMs,
+                "ms)")));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true },
+                "Found ",
+                data.results.length,
+                " results for "),
+            React.createElement(Text, { color: "cyan" },
+                "\"",
+                data.query,
+                "\""),
+            React.createElement(Text, { dimColor: true },
+                " (",
+                data.elapsedMs,
+                "ms):")),
+        data.results.map((result, index) => (React.createElement(SearchResult, { key: `${result.filepath}:${result.startLine}-${index}`, result: result, maxWidth: maxSnippetWidth })))));
+}

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { IndexDisplayStats } from '../../common/types.js';
+type Props = {
+    version: string;
+    cwd: string;
+    isInitialized?: boolean;
+    indexStats: IndexDisplayStats | null | undefined;
+};
+export default function WelcomeBanner({ version, cwd, isInitialized, indexStats, }: Props): React.JSX.Element;
+export {};

package/dist/cli/components/WelcomeBanner.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import Gradient from 'ink-gradient';
+import BigText from 'ink-big-text';
+export default function WelcomeBanner({ version, cwd, isInitialized, indexStats, }) {
+    // indexStats is only passed once fully loaded (undefined means still loading)
+    const isIndexed = indexStats != null && indexStats.totalChunks > 0;
+    return (React.createElement(Box, { flexDirection: "column", paddingX: 1 },
+        React.createElement(Gradient, { colors: ['#9D4EDD', '#00D9FF'] },
+            React.createElement(BigText, { text: "VibeRAG" })),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Box, null,
+                React.createElement(Text, { dimColor: true },
+                    "v",
+                    version),
+                isInitialized === true && isIndexed && (React.createElement(React.Fragment, null,
+                    React.createElement(Text, null, " "),
+                    React.createElement(Text, { color: "green" }, "\u2713 Ready")))),
+            React.createElement(Text, { dimColor: true }, cwd)),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Type /help for available commands")),
+        isInitialized === false && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "Run /init to set up"))),
+        isInitialized === true && !isIndexed && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "Run /index to build the code index")))));
+}

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

@@ -0,0 +1 @@
+export { default as WelcomeBanner } from './WelcomeBanner.js';

package/dist/cli/components/index.js

@@ -0,0 +1 @@
+export { default as WelcomeBanner } from './WelcomeBanner.js';

package/dist/cli/data/mcp-editors.d.ts

@@ -0,0 +1,80 @@
+/**
+ * MCP Editor Configuration Data
+ *
+ * Configuration for all supported AI coding tools and their MCP setup.
+ */
+/**
+ * Supported editor/agent identifiers.
+ */
+export type EditorId = 'claude-code' | 'vscode' | 'cursor' | 'windsurf' | 'roo-code' | 'zed' | 'gemini-cli' | 'codex' | 'jetbrains' | 'opencode';
+/**
+ * Configuration for an editor/agent's MCP setup.
+ */
+export interface EditorConfig {
+    /** Unique identifier */
+    id: EditorId;
+    /** Display name */
+    name: string;
+    /** Config file path (null = no file config, ~ expanded at runtime) */
+    configPath: string | null;
+    /** Config file format */
+    configFormat: 'json' | 'toml' | 'ui';
+    /** Configuration scope */
+    scope: 'project' | 'global' | 'ui';
+    /** Whether we can auto-create the config */
+    canAutoCreate: boolean;
+    /** CLI command if available (null = none) */
+    cliCommand: string | null;
+    /** Official documentation URL */
+    docsUrl: string;
+    /** JSON key for servers object */
+    jsonKey: string;
+    /** Short description for wizard */
+    description: string;
+    /** Restart/reload instructions */
+    restartInstructions: string;
+    /** Verification steps */
+    verificationSteps: string[];
+}
+/**
+ * All supported editors with their MCP configurations.
+ * Sorted alphabetically by name.
+ */
+export declare const EDITORS: EditorConfig[];
+/**
+ * Get editor by ID.
+ */
+export declare function getEditor(id: EditorId): EditorConfig | undefined;
+/**
+ * Get editors that support auto-creation of project-level config.
+ */
+export declare function getAutoCreateEditors(): EditorConfig[];
+/**
+ * Get editors that require global config merging.
+ */
+export declare function getGlobalConfigEditors(): EditorConfig[];
+/**
+ * Get editors that have CLI commands.
+ */
+export declare function getCliCommandEditors(): EditorConfig[];
+/**
+ * Expand ~ to home directory in path.
+ */
+export declare function expandPath(configPath: string): string;
+/**
+ * Get the absolute config path for an editor.
+ * For project-scope editors, projectRoot is required.
+ */
+export declare function getConfigPath(editor: EditorConfig, projectRoot?: string): string | null;
+/**
+ * Get Zed settings path based on platform.
+ */
+export declare function getZedSettingsPath(): string;
+/**
+ * Get Windsurf config path based on platform.
+ */
+export declare function getWindsurfConfigPath(): string;
+/**
+ * Get OpenCode config path based on platform.
+ */
+export declare function getOpenCodeConfigPath(): string;