viberag 0.1.0

package/dist/cli/commands/mcp-setup.js

@@ -0,0 +1,509 @@
+/**
+ * MCP Setup Logic
+ *
+ * Functions for generating, writing, and merging MCP configurations
+ * for various AI coding tools.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { EDITORS, getConfigPath, getZedSettingsPath, getWindsurfConfigPath, getOpenCodeConfigPath, } from '../data/mcp-editors.js';
+/**
+ * Generate the viberag MCP server configuration object.
+ */
+export function generateViberagConfig() {
+    return {
+        command: 'npx',
+        args: ['viberag-mcp'],
+    };
+}
+/**
+ * Generate OpenCode-specific viberag MCP server configuration.
+ * OpenCode requires: type="local", command as array, no args key.
+ */
+export function generateOpenCodeViberagConfig() {
+    return {
+        type: 'local',
+        command: ['npx', '-y', 'viberag-mcp'],
+    };
+}
+/**
+ * Generate complete MCP config for an editor.
+ */
+export function generateMcpConfig(editor) {
+    const viberagConfig = editor.id === 'opencode'
+        ? generateOpenCodeViberagConfig()
+        : generateViberagConfig();
+    // Use the editor's specific key
+    return {
+        [editor.jsonKey]: {
+            viberag: viberagConfig,
+        },
+    };
+}
+/**
+ * Generate TOML config for OpenAI Codex.
+ */
+export function generateTomlConfig() {
+    return `[mcp_servers.viberag]
+command = "npx"
+args = ["viberag-mcp"]
+`;
+}
+/**
+ * Check if a config file exists.
+ */
+export async function configExists(configPath) {
+    try {
+        await fs.access(configPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read existing config file as JSON.
+ */
+export async function readJsonConfig(configPath) {
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Merge viberag config into existing config.
+ */
+export function mergeConfig(existing, editor) {
+    const viberagConfig = editor.id === 'opencode'
+        ? generateOpenCodeViberagConfig()
+        : generateViberagConfig();
+    const jsonKey = editor.jsonKey;
+    // Get or create the servers object
+    const existingServers = existing[jsonKey] ?? {};
+    return {
+        ...existing,
+        [jsonKey]: {
+            ...existingServers,
+            viberag: viberagConfig,
+        },
+    };
+}
+/**
+ * Check if viberag is already configured in a config file.
+ */
+export function hasViberagConfig(config, editor) {
+    const servers = config[editor.jsonKey];
+    if (!servers || typeof servers !== 'object') {
+        return false;
+    }
+    return 'viberag' in servers;
+}
+/**
+ * Write MCP config to file, creating directories as needed.
+ */
+export async function writeMcpConfig(editor, projectRoot) {
+    try {
+        // Get the config path
+        let configPath;
+        if (editor.id === 'zed') {
+            configPath = getZedSettingsPath();
+        }
+        else if (editor.id === 'windsurf') {
+            configPath = getWindsurfConfigPath();
+        }
+        else if (editor.id === 'opencode') {
+            configPath = getOpenCodeConfigPath();
+        }
+        else {
+            const path = getConfigPath(editor, projectRoot);
+            if (!path) {
+                return {
+                    success: false,
+                    editor: editor.id,
+                    method: 'instructions-shown',
+                    error: 'No config path for this editor',
+                };
+            }
+            configPath = path;
+        }
+        // Ensure parent directory exists
+        const dir = path.dirname(configPath);
+        await fs.mkdir(dir, { recursive: true });
+        // Check if file exists
+        const exists = await configExists(configPath);
+        if (exists) {
+            // Merge with existing config
+            const existing = await readJsonConfig(configPath);
+            if (!existing) {
+                return {
+                    success: false,
+                    editor: editor.id,
+                    method: 'instructions-shown',
+                    error: 'Could not parse existing config file',
+                };
+            }
+            // Check if already configured
+            if (hasViberagConfig(existing, editor)) {
+                return {
+                    success: true,
+                    editor: editor.id,
+                    method: 'file-merged',
+                    configPath,
+                    error: 'Already configured',
+                };
+            }
+            const merged = mergeConfig(existing, editor);
+            await fs.writeFile(configPath, JSON.stringify(merged, null, 2) + '\n');
+            return {
+                success: true,
+                editor: editor.id,
+                method: 'file-merged',
+                configPath,
+            };
+        }
+        else {
+            // Create new config
+            const config = generateMcpConfig(editor);
+            await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+            return {
+                success: true,
+                editor: editor.id,
+                method: 'file-created',
+                configPath,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            editor: editor.id,
+            method: 'instructions-shown',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Generate manual setup instructions for an editor.
+ */
+export function getManualInstructions(editor, projectRoot) {
+    const lines = [];
+    lines.push(`## ${editor.name} MCP Setup`);
+    lines.push('');
+    if (editor.cliCommand) {
+        lines.push('Run this command:');
+        lines.push('');
+        lines.push(`  ${editor.cliCommand}`);
+        lines.push('');
+    }
+    else if (editor.configFormat === 'json') {
+        let configPath;
+        if (editor.id === 'opencode') {
+            configPath = getOpenCodeConfigPath();
+        }
+        else if (editor.scope === 'project') {
+            configPath = editor.configPath;
+        }
+        else {
+            const resolvedPath = getConfigPath(editor, projectRoot);
+            configPath = resolvedPath ?? editor.configPath;
+        }
+        lines.push(`Add to ${configPath}:`);
+        lines.push('');
+        const config = generateMcpConfig(editor);
+        const jsonStr = JSON.stringify(config, null, 2);
+        lines.push(jsonStr
+            .split('\n')
+            .map(l => '  ' + l)
+            .join('\n'));
+        lines.push('');
+    }
+    else if (editor.configFormat === 'toml') {
+        lines.push(`Add to ${editor.configPath}:`);
+        lines.push('');
+        lines.push(generateTomlConfig()
+            .split('\n')
+            .map(l => '  ' + l)
+            .join('\n'));
+        lines.push('');
+    }
+    else if (editor.configFormat === 'ui') {
+        lines.push('Manual setup required:');
+        lines.push('');
+        lines.push('1. Open Settings → Tools → AI Assistant → MCP');
+        lines.push('2. Click "Add Server"');
+        lines.push('3. Set name: viberag');
+        lines.push('4. Set command: npx');
+        lines.push('5. Set args: viberag-mcp');
+        lines.push('');
+    }
+    lines.push('After setup:');
+    lines.push(`  ${editor.restartInstructions}`);
+    lines.push('');
+    lines.push('Verify:');
+    for (const step of editor.verificationSteps) {
+        lines.push(`  - ${step}`);
+    }
+    lines.push('');
+    lines.push(`Documentation: ${editor.docsUrl}`);
+    return lines.join('\n');
+}
+/**
+ * Get a diff preview of the merge operation.
+ */
+export async function getMergeDiff(editor, projectRoot) {
+    try {
+        let configPath;
+        if (editor.id === 'zed') {
+            configPath = getZedSettingsPath();
+        }
+        else if (editor.id === 'windsurf') {
+            configPath = getWindsurfConfigPath();
+        }
+        else if (editor.id === 'opencode') {
+            configPath = getOpenCodeConfigPath();
+        }
+        else {
+            const path = getConfigPath(editor, projectRoot);
+            if (!path)
+                return null;
+            configPath = path;
+        }
+        const exists = await configExists(configPath);
+        if (!exists) {
+            return {
+                before: '(file does not exist)',
+                after: JSON.stringify(generateMcpConfig(editor), null, 2),
+                configPath,
+            };
+        }
+        const existing = await readJsonConfig(configPath);
+        if (!existing)
+            return null;
+        const merged = mergeConfig(existing, editor);
+        return {
+            before: JSON.stringify(existing, null, 2),
+            after: JSON.stringify(merged, null, 2),
+            configPath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if viberag is already configured for an editor.
+ */
+export async function isAlreadyConfigured(editor, projectRoot) {
+    try {
+        let configPath;
+        if (editor.id === 'zed') {
+            configPath = getZedSettingsPath();
+        }
+        else if (editor.id === 'windsurf') {
+            configPath = getWindsurfConfigPath();
+        }
+        else if (editor.id === 'opencode') {
+            configPath = getOpenCodeConfigPath();
+        }
+        else {
+            const path = getConfigPath(editor, projectRoot);
+            if (!path)
+                return false;
+            configPath = path;
+        }
+        const exists = await configExists(configPath);
+        if (!exists)
+            return false;
+        const config = await readJsonConfig(configPath);
+        if (!config)
+            return false;
+        return hasViberagConfig(config, editor);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove viberag from an existing config object.
+ * Returns the modified config, or null if nothing to remove.
+ */
+export function removeViberagFromConfig(existing, editor) {
+    const jsonKey = editor.jsonKey;
+    const servers = existing[jsonKey];
+    if (!servers || typeof servers !== 'object') {
+        return null;
+    }
+    if (!('viberag' in servers)) {
+        return null;
+    }
+    // Remove viberag from servers
+    const remainingServers = Object.fromEntries(Object.entries(servers).filter(([key]) => key !== 'viberag'));
+    return {
+        ...existing,
+        [jsonKey]: remainingServers,
+    };
+}
+/**
+ * Remove viberag from an editor's MCP config.
+ * Always keeps the config file, even if it becomes empty (no other servers).
+ */
+export async function removeViberagConfig(editor, projectRoot) {
+    try {
+        // Get the config path
+        let configPath;
+        if (editor.id === 'zed') {
+            configPath = getZedSettingsPath();
+        }
+        else if (editor.id === 'windsurf') {
+            configPath = getWindsurfConfigPath();
+        }
+        else if (editor.id === 'opencode') {
+            configPath = getOpenCodeConfigPath();
+        }
+        else {
+            const p = getConfigPath(editor, projectRoot);
+            if (!p) {
+                return {
+                    success: false,
+                    editor: editor.id,
+                    error: 'No config path for this editor',
+                };
+            }
+            configPath = p;
+        }
+        // Check if file exists
+        const exists = await configExists(configPath);
+        if (!exists) {
+            return {
+                success: false,
+                editor: editor.id,
+                error: 'Config file does not exist',
+            };
+        }
+        // Read existing config
+        const existing = await readJsonConfig(configPath);
+        if (!existing) {
+            return {
+                success: false,
+                editor: editor.id,
+                configPath,
+                error: 'Could not parse config file',
+            };
+        }
+        // Check if viberag is configured
+        if (!hasViberagConfig(existing, editor)) {
+            return {
+                success: false,
+                editor: editor.id,
+                configPath,
+                error: 'Viberag not configured in this file',
+            };
+        }
+        // Remove viberag
+        const modified = removeViberagFromConfig(existing, editor);
+        if (!modified) {
+            return {
+                success: false,
+                editor: editor.id,
+                configPath,
+                error: 'Failed to remove viberag from config',
+            };
+        }
+        // Write modified config back (keep file even if servers is empty)
+        await fs.writeFile(configPath, JSON.stringify(modified, null, 2) + '\n');
+        return {
+            success: true,
+            editor: editor.id,
+            configPath,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            editor: editor.id,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Find all editors that have viberag configured.
+ * Returns both project-scope and global-scope editors.
+ */
+export async function findConfiguredEditors(projectRoot) {
+    const projectScope = [];
+    const globalScope = [];
+    for (const editor of EDITORS) {
+        const isConfigured = await isAlreadyConfigured(editor, projectRoot);
+        if (isConfigured) {
+            if (editor.scope === 'project') {
+                projectScope.push(editor);
+            }
+            else if (editor.scope === 'global') {
+                globalScope.push(editor);
+            }
+        }
+    }
+    return { projectScope, globalScope };
+}
+/**
+ * Add an entry to .gitignore if not already present.
+ */
+export async function addToGitignore(projectRoot, entry) {
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    try {
+        let content = '';
+        try {
+            content = await fs.readFile(gitignorePath, 'utf-8');
+        }
+        catch {
+            // .gitignore doesn't exist, will create
+        }
+        // Check if entry already exists (exact line match)
+        const lines = content.split('\n');
+        if (lines.some(line => line.trim() === entry)) {
+            return true; // Already present
+        }
+        // Add entry with a comment
+        const addition = content.endsWith('\n') || content === ''
+            ? `# MCP config (local, not committed)\n${entry}\n`
+            : `\n# MCP config (local, not committed)\n${entry}\n`;
+        await fs.appendFile(gitignorePath, addition);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get all project-scope config paths that were created.
+ * Used for gitignore prompt.
+ */
+export function getProjectConfigPaths(results) {
+    const paths = [];
+    for (const result of results) {
+        if (result.success &&
+            (result.method === 'file-created' || result.method === 'file-merged') &&
+            result.configPath) {
+            // Check if it's a project-scope path (doesn't start with ~ or /)
+            const configPath = result.configPath;
+            if (!configPath.startsWith('/') && !configPath.startsWith('~')) {
+                // It's a relative path, so project-scope
+                paths.push(configPath);
+            }
+            else if (configPath.includes('.mcp.json') ||
+                configPath.includes('.cursor/') ||
+                configPath.includes('.vscode/') ||
+                configPath.includes('.roo/')) {
+                // Extract relative path from absolute path
+                const projectDir = process.cwd();
+                if (configPath.startsWith(projectDir)) {
+                    paths.push(configPath.slice(projectDir.length + 1));
+                }
+            }
+        }
+    }
+    return paths;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * CLI command handling hook.
+ * Consolidates all command routing and handler implementations.
+ */
+import { type IndexDisplayStats } from './handlers.js';
+import type { AppStatus, SearchResultsData } from '../../common/types.js';
+type RagCommandContext = {
+    addOutput: (type: 'user' | 'system', content: string) => void;
+    addSearchResults: (data: SearchResultsData) => void;
+    setAppStatus: (status: AppStatus) => void;
+    setIndexStats: (stats: IndexDisplayStats | null) => void;
+    projectRoot: string;
+    stdout: NodeJS.WriteStream;
+    startInitWizard: (isReinit: boolean) => void;
+    startMcpSetupWizard: (showPrompt?: boolean) => void;
+    startCleanWizard: () => void;
+    isInitialized: boolean;
+};
+export declare function useRagCommands({ addOutput, addSearchResults, setAppStatus, setIndexStats, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }: RagCommandContext): {
+    isCommand: (text: string) => boolean;
+    executeCommand: (text: string) => void;
+};
+export {};

package/dist/cli/commands/useRagCommands.js

@@ -0,0 +1,180 @@
+/**
+ * CLI command handling hook.
+ * Consolidates all command routing and handler implementations.
+ */
+import { useCallback } from 'react';
+import { useApp } from 'ink';
+import { runIndex, formatIndexStats, runSearch, getStatus, loadIndexStats, } from './handlers.js';
+import { setupVSCodeTerminal } from '../../common/commands/terminalSetup.js';
+export function useRagCommands({ addOutput, addSearchResults, setAppStatus, setIndexStats, projectRoot, stdout, startInitWizard, startMcpSetupWizard, startCleanWizard, isInitialized, }) {
+    const { exit } = useApp();
+    // Command handlers
+    const handleHelp = useCallback(() => {
+        addOutput('system', `Commands:
+  /help           - Show this help
+  /clear          - Clear the screen
+  /terminal-setup - Configure terminal for Shift+Enter
+  /init           - Initialize Viberag (interactive wizard)
+  /index          - Index the codebase
+  /reindex        - Force full reindex
+  /search <query> - Search the codebase
+  /status         - Show index status
+  /mcp-setup      - Configure MCP server for AI coding tools
+  /clean          - Remove Viberag from project (delete .viberag/)
+  /quit           - Exit
+
+Multi-line input:
+  Shift+Enter     - iTerm2, Kitty, WezTerm (automatic)
+  Shift+Enter     - VS Code (requires /terminal-setup)
+  Option+Enter    - Most terminals
+  Ctrl+J          - All terminals
+  \\ then Enter    - All terminals
+
+Tips:
+  Ctrl+C          - Clear input (twice to quit)
+  Escape          - Clear input
+  Up/Down         - Command history`);
+    }, [addOutput]);
+    const handleClear = useCallback(() => {
+        // Clear screen (\x1B[2J), clear scrollback buffer (\x1B[3J), move cursor home (\x1B[H)
+        stdout.write('\x1B[2J\x1B[3J\x1B[H');
+    }, [stdout]);
+    const handleTerminalSetup = useCallback(() => {
+        setupVSCodeTerminal()
+            .then(result => addOutput('system', result))
+            .catch(err => addOutput('system', `Error: ${err.message}`));
+    }, [addOutput]);
+    // Trigger init wizard
+    const handleInit = useCallback(() => {
+        startInitWizard(isInitialized);
+    }, [startInitWizard, isInitialized]);
+    const handleIndex = useCallback((force) => {
+        const action = force ? 'Reindexing' : 'Indexing';
+        addOutput('system', `${action} codebase...`);
+        setAppStatus({ state: 'indexing', current: 0, total: 0, stage: action });
+        runIndex(projectRoot, force, (current, total, stage) => setAppStatus({ state: 'indexing', current, total, stage }))
+            .then(async (stats) => {
+            addOutput('system', formatIndexStats(stats));
+            // Reload stats after indexing
+            const newStats = await loadIndexStats(projectRoot);
+            setIndexStats(newStats);
+            setAppStatus({ state: 'ready' });
+        })
+            .catch(err => {
+            addOutput('system', `Index failed: ${err.message}`);
+            setAppStatus({ state: 'ready' });
+        });
+    }, [projectRoot, addOutput, setAppStatus, setIndexStats]);
+    const handleSearch = useCallback((query) => {
+        addOutput('system', `Searching for "${query}"...`);
+        setAppStatus({ state: 'searching' });
+        runSearch(projectRoot, query)
+            .then(results => {
+            // Use the component-based display with syntax highlighting
+            addSearchResults({
+                query: results.query,
+                elapsedMs: results.elapsedMs,
+                results: results.results.map(r => ({
+                    type: r.type,
+                    name: r.name,
+                    filepath: r.filepath,
+                    filename: r.filename,
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    score: r.score,
+                    text: r.text,
+                })),
+            });
+            setAppStatus({ state: 'ready' });
+        })
+            .catch(err => {
+            addOutput('system', `Search failed: ${err.message}`);
+            setAppStatus({ state: 'ready' });
+        });
+    }, [projectRoot, addOutput, addSearchResults, setAppStatus]);
+    const handleStatus = useCallback(() => {
+        getStatus(projectRoot)
+            .then(status => addOutput('system', status))
+            .catch(err => addOutput('system', `Status failed: ${err.message}`));
+    }, [projectRoot, addOutput]);
+    const handleMcpSetup = useCallback(() => {
+        startMcpSetupWizard(false); // showPrompt = false for direct /mcp-setup command
+    }, [startMcpSetupWizard]);
+    const handleClean = useCallback(() => {
+        startCleanWizard();
+    }, [startCleanWizard]);
+    const handleUnknown = useCallback((command) => {
+        addOutput('system', `Unknown command: ${command}. Type /help for available commands.`);
+    }, [addOutput]);
+    // Command detection
+    const isCommand = useCallback((text) => {
+        return text.trim().startsWith('/');
+    }, []);
+    // Command routing
+    const executeCommand = useCallback((text) => {
+        const trimmed = text.trim();
+        const command = trimmed.toLowerCase();
+        // Handle commands with arguments
+        if (command.startsWith('/search ')) {
+            const query = trimmed.slice('/search '.length).trim();
+            if (query) {
+                handleSearch(query);
+            }
+            else {
+                handleUnknown('/search (missing query)');
+            }
+            return;
+        }
+        switch (command) {
+            case '/help':
+                handleHelp();
+                break;
+            case '/clear':
+                handleClear();
+                break;
+            case '/terminal-setup':
+                handleTerminalSetup();
+                break;
+            case '/init':
+                handleInit();
+                break;
+            case '/index':
+                handleIndex(false);
+                break;
+            case '/reindex':
+                handleIndex(true);
+                break;
+            case '/status':
+                handleStatus();
+                break;
+            case '/mcp-setup':
+                handleMcpSetup();
+                break;
+            case '/clean':
+            case '/uninstall':
+                handleClean();
+                break;
+            case '/quit':
+            case '/exit':
+            case '/q':
+                exit();
+                break;
+            default:
+                handleUnknown(command);
+                break;
+        }
+    }, [
+        exit,
+        handleHelp,
+        handleClear,
+        handleTerminalSetup,
+        handleInit,
+        handleIndex,
+        handleSearch,
+        handleStatus,
+        handleMcpSetup,
+        handleClean,
+        handleUnknown,
+    ]);
+    return { isCommand, executeCommand };
+}