viberag 0.1.0

package/dist/cli/app.js

@@ -0,0 +1,238 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { createRequire } from 'node:module';
+import { Box, Text, useStdout } from 'ink';
+// Common infrastructure
+import TextInput from '../common/components/TextInput.js';
+import StatusBar from '../common/components/StatusBar.js';
+import StaticWithResize from '../common/components/StaticWithResize.js';
+import { useCtrlC } from '../common/hooks/useCtrlC.js';
+import { useCommandHistory } from '../common/hooks/useCommandHistory.js';
+import { useKittyKeyboard } from '../common/hooks/useKittyKeyboard.js';
+// CLI-specific components and commands
+import WelcomeBanner from './components/WelcomeBanner.js';
+import SearchResultsDisplay from './components/SearchResultsDisplay.js';
+import InitWizard from './components/InitWizard.js';
+import McpSetupWizard from './components/McpSetupWizard.js';
+import CleanWizard from './components/CleanWizard.js';
+import { useRagCommands } from './commands/useRagCommands.js';
+import { checkInitialized, loadIndexStats, runInit, runIndex, formatIndexStats, } from './commands/handlers.js';
+import { getViberagDir, loadConfig } from '../rag/index.js';
+const require = createRequire(import.meta.url);
+// Path is relative from dist/ after compilation
+const { version } = require('../../package.json');
+// Available slash commands for autocomplete with descriptions
+const COMMANDS = [
+    { command: '/help', description: 'Show available commands' },
+    { command: '/clear', description: 'Clear the screen' },
+    {
+        command: '/terminal-setup',
+        description: 'Configure Shift+Enter for VS Code',
+    },
+    { command: '/init', description: 'Initialize Viberag (provider wizard)' },
+    { command: '/index', description: 'Index the codebase' },
+    { command: '/reindex', description: 'Force full reindex' },
+    { command: '/search', description: 'Search codebase semantically' },
+    { command: '/status', description: 'Show index statistics' },
+    { command: '/mcp-setup', description: 'Configure MCP for AI tools' },
+    { command: '/clean', description: 'Remove Viberag from project' },
+    { command: '/quit', description: 'Exit the application' },
+];
+// Module-level counter for unique IDs
+let nextId = 0;
+export default function App() {
+    const [outputItems, setOutputItems] = useState([]);
+    const [appStatus, setAppStatus] = useState({ state: 'ready' });
+    // undefined = not loaded yet, null = loaded but no manifest, {...} = loaded with stats
+    const [indexStats, setIndexStats] = useState(undefined);
+    const [isInitialized, setIsInitialized] = useState(undefined);
+    const [wizardMode, setWizardMode] = useState({ active: false });
+    // Existing config for reinit flow (API key preservation)
+    const [existingApiKey, setExistingApiKey] = useState(undefined);
+    const [existingProvider, setExistingProvider] = useState(undefined);
+    const { stdout } = useStdout();
+    // Enable Kitty keyboard protocol for Shift+Enter support in iTerm2/Kitty/WezTerm
+    useKittyKeyboard();
+    // Get project root (current working directory)
+    const projectRoot = process.cwd();
+    // Check initialization status and load stats on mount
+    useEffect(() => {
+        checkInitialized(projectRoot).then(async (initialized) => {
+            setIsInitialized(initialized);
+            // Load existing config for API key preservation during reinit
+            if (initialized) {
+                const config = await loadConfig(projectRoot);
+                setExistingApiKey(config.apiKey);
+                setExistingProvider(config.embeddingProvider);
+            }
+        });
+        loadIndexStats(projectRoot).then(setIndexStats);
+    }, [projectRoot]);
+    // Command history
+    const { addToHistory, navigateUp, navigateDown, resetIndex } = useCommandHistory();
+    const addOutput = (type, content) => {
+        const id = String(nextId++);
+        setOutputItems(prev => [
+            ...prev,
+            {
+                id,
+                type,
+                content,
+            },
+        ]);
+    };
+    const addSearchResults = (data) => {
+        const id = String(nextId++);
+        setOutputItems(prev => [
+            ...prev,
+            {
+                id,
+                type: 'search-results',
+                data,
+            },
+        ]);
+    };
+    // Start the init wizard
+    const startInitWizard = useCallback((isReinit) => {
+        setWizardMode({ active: true, type: 'init', step: 0, config: {}, isReinit });
+    }, []);
+    // Start the MCP setup wizard
+    const startMcpSetupWizard = useCallback((showPrompt = false) => {
+        setWizardMode({
+            active: true,
+            type: 'mcp-setup',
+            step: showPrompt ? 'prompt' : 'select',
+            config: {},
+            showPrompt,
+        });
+    }, []);
+    // Start the clean wizard
+    const startCleanWizard = useCallback(() => {
+        setWizardMode({ active: true, type: 'clean' });
+    }, []);
+    // Handle clean wizard completion
+    const handleCleanWizardComplete = useCallback(() => {
+        setWizardMode({ active: false });
+        // Reset app state to uninitialized after cleaning
+        setIndexStats(null);
+        setIsInitialized(false);
+    }, []);
+    // Handle init wizard step changes
+    const handleInitWizardStep = useCallback((step, data) => {
+        setWizardMode(prev => prev.active && prev.type === 'init'
+            ? { ...prev, step, config: { ...prev.config, ...data } }
+            : prev);
+    }, []);
+    // Handle MCP wizard step changes
+    const handleMcpWizardStep = useCallback((step, data) => {
+        setWizardMode(prev => prev.active && prev.type === 'mcp-setup'
+            ? { ...prev, step, config: { ...prev.config, ...data } }
+            : prev);
+    }, []);
+    // Handle init wizard completion
+    const handleInitWizardComplete = useCallback(async (config) => {
+        // Close wizard first, then run init after a tick to ensure proper re-render
+        setWizardMode({ active: false });
+        // Wait for next tick so wizard unmounts before we add output
+        await new Promise(resolve => setTimeout(resolve, 50));
+        addOutput('system', 'Initializing Viberag...');
+        setAppStatus({ state: 'warning', message: 'Initializing...' });
+        try {
+            const result = await runInit(projectRoot, isInitialized ?? false, config);
+            addOutput('system', result);
+            setIsInitialized(true);
+            // Automatically start indexing after init
+            addOutput('system', 'Indexing codebase...');
+            setAppStatus({
+                state: 'indexing',
+                current: 0,
+                total: 0,
+                stage: 'Indexing',
+            });
+            const stats = await runIndex(projectRoot, true, (current, total, stage) => setAppStatus({ state: 'indexing', current, total, stage }));
+            addOutput('system', formatIndexStats(stats));
+            // Reload stats after indexing
+            const newStats = await loadIndexStats(projectRoot);
+            setIndexStats(newStats);
+            setAppStatus({ state: 'ready' });
+            // Prompt for MCP setup after init completes
+            await new Promise(resolve => setTimeout(resolve, 100));
+            startMcpSetupWizard(true); // showPrompt = true for post-init flow
+        }
+        catch (err) {
+            addOutput('system', `Init failed: ${err instanceof Error ? err.message : String(err)}`);
+            setAppStatus({ state: 'ready' });
+        }
+    }, [projectRoot, isInitialized, startMcpSetupWizard]);
+    // Handle MCP wizard completion
+    const handleMcpWizardComplete = useCallback((_config) => {
+        setWizardMode({ active: false });
+        // Results are already shown in the wizard summary
+    }, []);
+    // Handle wizard cancellation
+    const handleWizardCancel = useCallback(() => {
+        const wasInit = wizardMode.active && wizardMode.type === 'init';
+        setWizardMode({ active: false });
+        if (wasInit) {
+            addOutput('system', 'Initialization cancelled.');
+        }
+        // MCP wizard cancel just closes silently
+    }, [wizardMode]);
+    // Handle Ctrl+C with status message callback
+    const { handleCtrlC } = useCtrlC({
+        onFirstPress: () => setAppStatus({ state: 'warning', message: 'Press Ctrl+C again to quit' }),
+        onStatusClear: () => setAppStatus({ state: 'ready' }),
+    });
+    // Command handling (all logic consolidated in useRagCommands)
+    const { isCommand, executeCommand } = useRagCommands({
+        addOutput,
+        addSearchResults,
+        setAppStatus,
+        setIndexStats,
+        projectRoot,
+        stdout,
+        startInitWizard,
+        startMcpSetupWizard,
+        startCleanWizard,
+        isInitialized: isInitialized ?? false,
+    });
+    const handleSubmit = (text) => {
+        if (!text.trim())
+            return;
+        // Add to history
+        addToHistory(text);
+        // Always show user input
+        addOutput('user', text);
+        if (isCommand(text)) {
+            executeCommand(text);
+        }
+        else {
+            // Placeholder for actual processing - just echo for now
+            addOutput('system', `Echo: ${text}`);
+        }
+    };
+    // Prepend welcome banner as first static item (only after BOTH init status AND stats are loaded)
+    // This prevents race condition where banner shows stale "Run /index" while stats are loading
+    const startupLoaded = isInitialized !== undefined && indexStats !== undefined;
+    const staticItems = [
+        ...(startupLoaded
+            ? [{ id: 'welcome', type: 'welcome', content: '' }]
+            : []),
+        ...outputItems,
+    ];
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(StaticWithResize, { items: staticItems }, item => {
+            if (item.type === 'welcome') {
+                return (React.createElement(Box, { key: item.id, marginBottom: 1 },
+                    React.createElement(WelcomeBanner, { version: version, cwd: process.cwd(), isInitialized: isInitialized, indexStats: indexStats })));
+            }
+            if (item.type === 'search-results') {
+                return (React.createElement(Box, { key: item.id, paddingX: 1, marginBottom: 1 },
+                    React.createElement(SearchResultsDisplay, { data: item.data })));
+            }
+            return (React.createElement(Box, { key: item.id, paddingX: 1, marginBottom: 1 }, item.type === 'user' ? (React.createElement(Text, { color: "cyan" },
+                "> ",
+                item.content)) : (React.createElement(Text, null, item.content))));
+        }),
+        React.createElement(StatusBar, { status: appStatus, stats: indexStats }),
+        wizardMode.active && wizardMode.type === 'init' ? (React.createElement(InitWizard, { step: wizardMode.step, config: wizardMode.config, isReinit: wizardMode.isReinit, existingApiKey: existingApiKey, existingProvider: existingProvider, onStepChange: handleInitWizardStep, onComplete: handleInitWizardComplete, onCancel: handleWizardCancel })) : wizardMode.active && wizardMode.type === 'mcp-setup' ? (React.createElement(McpSetupWizard, { step: wizardMode.step, config: wizardMode.config, projectRoot: projectRoot, showPrompt: wizardMode.showPrompt, onStepChange: handleMcpWizardStep, onComplete: handleMcpWizardComplete, onCancel: handleWizardCancel, addOutput: addOutput })) : wizardMode.active && wizardMode.type === 'clean' ? (React.createElement(CleanWizard, { projectRoot: projectRoot, viberagDir: getViberagDir(projectRoot), onComplete: handleCleanWizardComplete, onCancel: handleWizardCancel, addOutput: addOutput })) : (React.createElement(TextInput, { onSubmit: handleSubmit, onCtrlC: handleCtrlC, commands: COMMANDS, navigateHistoryUp: navigateUp, navigateHistoryDown: navigateDown, resetHistoryIndex: resetIndex }))));
+}

package/dist/cli/commands/handlers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * RAG commands for the CLI.
+ */
+import { type IndexStats, type SearchResults } from '../../rag/index.js';
+import type { InitWizardConfig } from '../../common/types.js';
+/**
+ * Index display stats type (re-exported for convenience).
+ */
+export type IndexDisplayStats = {
+    totalFiles: number;
+    totalChunks: number;
+};
+/**
+ * Check if project is initialized.
+ */
+export declare function checkInitialized(projectRoot: string): Promise<boolean>;
+/**
+ * Load index stats for display in status bar.
+ */
+export declare function loadIndexStats(projectRoot: string): Promise<IndexDisplayStats | null>;
+/**
+ * Initialize a project for Viberag.
+ * Creates .viberag/ directory with config.json.
+ * With isReinit=true, deletes everything and starts fresh.
+ */
+export declare function runInit(projectRoot: string, isReinit?: boolean, wizardConfig?: InitWizardConfig): Promise<string>;
+/**
+ * Run the indexer and return stats.
+ * When force=true, also updates config dimensions to match current PROVIDER_CONFIGS
+ * (handles dimension changes after viberag upgrades).
+ */
+export declare function runIndex(projectRoot: string, force?: boolean, onProgress?: (current: number, total: number, stage: string) => void): Promise<IndexStats>;
+/**
+ * Format index stats for display.
+ */
+export declare function formatIndexStats(stats: IndexStats): string;
+/**
+ * Run a search query and return results.
+ */
+export declare function runSearch(projectRoot: string, query: string, limit?: number): Promise<SearchResults>;
+/**
+ * Format search results for display with colors.
+ */
+export declare function formatSearchResults(results: SearchResults): string;
+/**
+ * Get index status.
+ */
+export declare function getStatus(projectRoot: string): Promise<string>;
+/**
+ * Clean/uninstall Viberag from a project.
+ * Removes the entire .viberag/ directory.
+ */
+export declare function runClean(projectRoot: string): Promise<string>;
+/**
+ * Get MCP setup instructions for Claude Code.
+ */
+export declare function getMcpSetupInstructions(): string;

package/dist/cli/commands/handlers.js

@@ -0,0 +1,231 @@
+/**
+ * RAG commands for the CLI.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import { Indexer, SearchEngine, loadManifest, manifestExists, configExists, saveConfig, DEFAULT_CONFIG, PROVIDER_CONFIGS, getViberagDir, } from '../../rag/index.js';
+/**
+ * Check if project is initialized.
+ */
+export async function checkInitialized(projectRoot) {
+    return configExists(projectRoot);
+}
+/**
+ * Load index stats for display in status bar.
+ */
+export async function loadIndexStats(projectRoot) {
+    if (!(await manifestExists(projectRoot))) {
+        return null;
+    }
+    const manifest = await loadManifest(projectRoot);
+    return {
+        totalFiles: manifest.stats.totalFiles,
+        totalChunks: manifest.stats.totalChunks,
+    };
+}
+/**
+ * Initialize a project for Viberag.
+ * Creates .viberag/ directory with config.json.
+ * With isReinit=true, deletes everything and starts fresh.
+ */
+export async function runInit(projectRoot, isReinit = false, wizardConfig) {
+    const viberagDir = getViberagDir(projectRoot);
+    const isExisting = await configExists(projectRoot);
+    // If reinit, delete entire .viberag directory first
+    if (isReinit && isExisting) {
+        await fs.rm(viberagDir, { recursive: true, force: true });
+    }
+    // Create .viberag directory
+    await fs.mkdir(viberagDir, { recursive: true });
+    // Build config from wizard choices
+    const provider = wizardConfig?.provider ?? 'gemini';
+    const { model, dimensions } = PROVIDER_CONFIGS[provider];
+    const config = {
+        ...DEFAULT_CONFIG,
+        embeddingProvider: provider,
+        embeddingModel: model,
+        embeddingDimensions: dimensions,
+        ...(wizardConfig?.apiKey && { apiKey: wizardConfig.apiKey }),
+    };
+    // Save config
+    await saveConfig(projectRoot, config);
+    // Add .viberag/ to .gitignore if not present
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        if (!content.includes('.viberag')) {
+            await fs.appendFile(gitignorePath, '\n# Viberag index\n.viberag/\n');
+        }
+    }
+    catch {
+        // .gitignore doesn't exist, create it
+        await fs.writeFile(gitignorePath, '# Viberag index\n.viberag/\n');
+    }
+    const action = isExisting ? 'Reinitialized' : 'Initialized';
+    const providerLabel = provider.charAt(0).toUpperCase() + provider.slice(1);
+    return `${action} Viberag in ${viberagDir}\nProvider: ${providerLabel}\nModel: ${model} (${dimensions}d)\nRun /index to build the code index.`;
+}
+/**
+ * Run the indexer and return stats.
+ * When force=true, also updates config dimensions to match current PROVIDER_CONFIGS
+ * (handles dimension changes after viberag upgrades).
+ */
+export async function runIndex(projectRoot, force = false, onProgress) {
+    // When forcing reindex, sync config dimensions with current provider settings
+    // This handles cases where PROVIDER_CONFIGS dimensions changed (e.g., Gemini 768→1536)
+    if (force) {
+        const { loadConfig } = await import('../../rag/config/index.js');
+        const config = await loadConfig(projectRoot);
+        const currentDimensions = PROVIDER_CONFIGS[config.embeddingProvider]?.dimensions;
+        if (currentDimensions && config.embeddingDimensions !== currentDimensions) {
+            const updatedConfig = {
+                ...config,
+                embeddingDimensions: currentDimensions,
+                embeddingModel: PROVIDER_CONFIGS[config.embeddingProvider].model,
+            };
+            await saveConfig(projectRoot, updatedConfig);
+        }
+    }
+    const indexer = new Indexer(projectRoot);
+    try {
+        const stats = await indexer.index({
+            force,
+            progressCallback: onProgress,
+        });
+        return stats;
+    }
+    finally {
+        indexer.close();
+    }
+}
+/**
+ * Format index stats for display.
+ */
+export function formatIndexStats(stats) {
+    const lines = [
+        'Index complete:',
+        `  Files scanned: ${stats.filesScanned}`,
+        `  New files: ${stats.filesNew}`,
+        `  Modified files: ${stats.filesModified}`,
+        `  Deleted files: ${stats.filesDeleted}`,
+        `  Chunks added: ${stats.chunksAdded}`,
+        `  Chunks deleted: ${stats.chunksDeleted}`,
+        `  Embeddings computed: ${stats.embeddingsComputed}`,
+        `  Embeddings cached: ${stats.embeddingsCached}`,
+    ];
+    return lines.join('\n');
+}
+/**
+ * Run a search query and return results.
+ */
+export async function runSearch(projectRoot, query, limit = 10) {
+    const engine = new SearchEngine(projectRoot);
+    try {
+        return await engine.search(query, { limit });
+    }
+    finally {
+        engine.close();
+    }
+}
+/**
+ * Color mapping for chunk types.
+ */
+const TYPE_COLORS = {
+    function: chalk.cyan,
+    class: chalk.magenta,
+    method: chalk.blue,
+    module: chalk.dim,
+};
+/**
+ * Get score color based on value.
+ */
+function getScoreColor(score) {
+    if (score > 0.8)
+        return chalk.green;
+    if (score > 0.5)
+        return chalk.yellow;
+    return chalk.red;
+}
+/**
+ * Format search results for display with colors.
+ */
+export function formatSearchResults(results) {
+    if (results.results.length === 0) {
+        return chalk.dim(`No results found for "${results.query}" (${results.elapsedMs}ms)`);
+    }
+    const lines = [
+        chalk.bold(`Found ${results.results.length} results for `) +
+            chalk.cyan(`"${results.query}"`) +
+            chalk.dim(` (${results.elapsedMs}ms):`),
+        '',
+    ];
+    for (const result of results.results) {
+        const typeColor = TYPE_COLORS[result.type] ?? chalk.white;
+        const scoreColor = getScoreColor(result.score);
+        // Type badge and name
+        lines.push(typeColor(`[${result.type}]`) +
+            (result.name ? ` ${chalk.white(result.name)}` : ''));
+        // File path and line numbers
+        lines.push(`  ${chalk.green(result.filepath)}` +
+            chalk.dim(`:${result.startLine}-${result.endLine}`));
+        // Score
+        lines.push(`  Score: ${scoreColor(result.score.toFixed(4))}`);
+        // Snippet (first 100 chars, dimmed)
+        const snippet = result.text.slice(0, 100).replace(/\n/g, ' ');
+        lines.push(chalk.dim(`  ${snippet}${result.text.length > 100 ? '...' : ''}`));
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Get index status.
+ */
+export async function getStatus(projectRoot) {
+    if (!(await manifestExists(projectRoot))) {
+        return 'No index found. Run /index to create one.';
+    }
+    const manifest = await loadManifest(projectRoot);
+    const lines = [
+        'Index status:',
+        `  Version: ${manifest.version}`,
+        `  Created: ${manifest.createdAt}`,
+        `  Updated: ${manifest.updatedAt}`,
+        `  Total files: ${manifest.stats.totalFiles}`,
+        `  Total chunks: ${manifest.stats.totalChunks}`,
+    ];
+    return lines.join('\n');
+}
+/**
+ * Clean/uninstall Viberag from a project.
+ * Removes the entire .viberag/ directory.
+ */
+export async function runClean(projectRoot) {
+    const viberagDir = getViberagDir(projectRoot);
+    const exists = await configExists(projectRoot);
+    if (!exists) {
+        return 'Viberag is not initialized in this project. Nothing to clean.';
+    }
+    await fs.rm(viberagDir, { recursive: true, force: true });
+    return `Removed ${viberagDir}\nViberag has been uninstalled from this project.\nRun /init to reinitialize.`;
+}
+/**
+ * Get MCP setup instructions for Claude Code.
+ */
+export function getMcpSetupInstructions() {
+    return `To add VibeRAG to Claude Code, run:
+
+  claude mcp add viberag -- npx viberag-mcp
+
+This registers VibeRAG as an MCP server. After adding:
+
+1. Restart Claude Code (or run: claude mcp restart viberag)
+2. The following tools will be available:
+   - codebase_search          Search the codebase semantically
+   - codebase_parallel_search  Run multiple searches in parallel
+   - viberag_index             Index or reindex the codebase
+   - viberag_status            Get index statistics
+
+Note: The project must be initialized first (run /init in the CLI).
+The MCP server uses the current working directory as the project root.`;
+}

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

@@ -0,0 +1,2 @@
+export * from './handlers.js';
+export { useRagCommands } from './useRagCommands.js';

package/dist/cli/commands/index.js

@@ -0,0 +1,2 @@
+export * from './handlers.js';
+export { useRagCommands } from './useRagCommands.js';

package/dist/cli/commands/mcp-setup.d.ts

@@ -0,0 +1,107 @@
+/**
+ * MCP Setup Logic
+ *
+ * Functions for generating, writing, and merging MCP configurations
+ * for various AI coding tools.
+ */
+import { type EditorConfig, type EditorId } from '../data/mcp-editors.js';
+/**
+ * Result of an MCP setup operation.
+ */
+export interface McpSetupResult {
+    success: boolean;
+    editor: EditorId;
+    method: 'file-created' | 'file-merged' | 'cli-command' | 'instructions-shown';
+    configPath?: string;
+    error?: string;
+}
+/**
+ * Generate the viberag MCP server configuration object.
+ */
+export declare function generateViberagConfig(): object;
+/**
+ * Generate OpenCode-specific viberag MCP server configuration.
+ * OpenCode requires: type="local", command as array, no args key.
+ */
+export declare function generateOpenCodeViberagConfig(): object;
+/**
+ * Generate complete MCP config for an editor.
+ */
+export declare function generateMcpConfig(editor: EditorConfig): object;
+/**
+ * Generate TOML config for OpenAI Codex.
+ */
+export declare function generateTomlConfig(): string;
+/**
+ * Check if a config file exists.
+ */
+export declare function configExists(configPath: string): Promise<boolean>;
+/**
+ * Read existing config file as JSON.
+ */
+export declare function readJsonConfig(configPath: string): Promise<object | null>;
+/**
+ * Merge viberag config into existing config.
+ */
+export declare function mergeConfig(existing: object, editor: EditorConfig): object;
+/**
+ * Check if viberag is already configured in a config file.
+ */
+export declare function hasViberagConfig(config: object, editor: EditorConfig): boolean;
+/**
+ * Write MCP config to file, creating directories as needed.
+ */
+export declare function writeMcpConfig(editor: EditorConfig, projectRoot: string): Promise<McpSetupResult>;
+/**
+ * Generate manual setup instructions for an editor.
+ */
+export declare function getManualInstructions(editor: EditorConfig, projectRoot: string): string;
+/**
+ * Get a diff preview of the merge operation.
+ */
+export declare function getMergeDiff(editor: EditorConfig, projectRoot: string): Promise<{
+    before: string;
+    after: string;
+    configPath: string;
+} | null>;
+/**
+ * Check if viberag is already configured for an editor.
+ */
+export declare function isAlreadyConfigured(editor: EditorConfig, projectRoot: string): Promise<boolean>;
+/**
+ * Remove viberag from an existing config object.
+ * Returns the modified config, or null if nothing to remove.
+ */
+export declare function removeViberagFromConfig(existing: object, editor: EditorConfig): object | null;
+/**
+ * Result of an MCP removal operation.
+ */
+export interface McpRemovalResult {
+    success: boolean;
+    editor: EditorId;
+    configPath?: string;
+    fileDeleted?: boolean;
+    error?: string;
+}
+/**
+ * Remove viberag from an editor's MCP config.
+ * Always keeps the config file, even if it becomes empty (no other servers).
+ */
+export declare function removeViberagConfig(editor: EditorConfig, projectRoot: string): Promise<McpRemovalResult>;
+/**
+ * Find all editors that have viberag configured.
+ * Returns both project-scope and global-scope editors.
+ */
+export declare function findConfiguredEditors(projectRoot: string): Promise<{
+    projectScope: EditorConfig[];
+    globalScope: EditorConfig[];
+}>;
+/**
+ * Add an entry to .gitignore if not already present.
+ */
+export declare function addToGitignore(projectRoot: string, entry: string): Promise<boolean>;
+/**
+ * Get all project-scope config paths that were created.
+ * Used for gitignore prompt.
+ */
+export declare function getProjectConfigPaths(results: McpSetupResult[]): string[];