viberag 0.1.0

package/dist/common/hooks/useCtrlC.d.ts

@@ -0,0 +1,9 @@
+type Options = {
+    onFirstPress: () => void;
+    onStatusClear: () => void;
+    timeout?: number;
+};
+export declare function useCtrlC({ onFirstPress, onStatusClear, timeout, }: Options): {
+    handleCtrlC: () => void;
+};
+export {};

package/dist/common/hooks/useCtrlC.js

@@ -0,0 +1,40 @@
+import { useRef, useCallback, useEffect } from 'react';
+import { useApp } from 'ink';
+export function useCtrlC({ onFirstPress, onStatusClear, timeout = 2000, }) {
+    const { exit } = useApp();
+    const lastPressTime = useRef(0);
+    const timeoutId = useRef(null);
+    // Cleanup timeout on unmount
+    useEffect(() => {
+        return () => {
+            if (timeoutId.current) {
+                clearTimeout(timeoutId.current);
+            }
+        };
+    }, []);
+    const handleCtrlC = useCallback(() => {
+        const now = Date.now();
+        const timeSinceLastPress = now - lastPressTime.current;
+        if (timeSinceLastPress < timeout && lastPressTime.current !== 0) {
+            // Second press within timeout - exit
+            if (timeoutId.current) {
+                clearTimeout(timeoutId.current);
+            }
+            exit();
+        }
+        else {
+            // First press - show message and start timer
+            lastPressTime.current = now;
+            onFirstPress();
+            // Clear the message after timeout
+            if (timeoutId.current) {
+                clearTimeout(timeoutId.current);
+            }
+            timeoutId.current = setTimeout(() => {
+                lastPressTime.current = 0;
+                onStatusClear();
+            }, timeout);
+        }
+    }, [exit, onFirstPress, onStatusClear, timeout]);
+    return { handleCtrlC };
+}

package/dist/common/hooks/useKittyKeyboard.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enables the Kitty keyboard protocol on mount and disables it on unmount.
+ *
+ * When enabled, terminals that support the protocol (iTerm2, Kitty, WezTerm)
+ * will send CSI u encoded key sequences that include modifier information.
+ * For example, Shift+Enter sends \x1b[13;2u instead of plain \r.
+ *
+ * Terminals that don't support the protocol simply ignore the escape sequence.
+ */
+export declare function useKittyKeyboard(): void;

package/dist/common/hooks/useKittyKeyboard.js

@@ -0,0 +1,26 @@
+import { useEffect } from 'react';
+import { useStdout } from 'ink';
+// Kitty keyboard protocol escape sequences
+// https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+const KITTY_ENABLE = '\x1b[>1u'; // Enable progressive enhancement mode 1
+const KITTY_DISABLE = '\x1b[<u'; // Pop/disable keyboard mode
+/**
+ * Enables the Kitty keyboard protocol on mount and disables it on unmount.
+ *
+ * When enabled, terminals that support the protocol (iTerm2, Kitty, WezTerm)
+ * will send CSI u encoded key sequences that include modifier information.
+ * For example, Shift+Enter sends \x1b[13;2u instead of plain \r.
+ *
+ * Terminals that don't support the protocol simply ignore the escape sequence.
+ */
+export function useKittyKeyboard() {
+    const { stdout } = useStdout();
+    useEffect(() => {
+        // Enable Kitty keyboard protocol on mount
+        stdout.write(KITTY_ENABLE);
+        // Disable on unmount
+        return () => {
+            stdout.write(KITTY_DISABLE);
+        };
+    }, [stdout]);
+}

package/dist/common/hooks/useStaticOutputBuffer.d.ts

@@ -0,0 +1,31 @@
+export type UseStaticOutputBufferResult = {
+    /**
+     * Append output to the buffer.
+     */
+    appendOutput: (id: string, content: string) => void;
+    /**
+     * Clear all buffered output.
+     */
+    clearOutput: () => void;
+    /**
+     * Get number of items in buffer.
+     */
+    getBufferSize: () => number;
+    /**
+     * Get the full buffer as a single string.
+     */
+    getFullBuffer: () => string;
+    /**
+     * Clear terminal and re-render all buffered output.
+     * This is the key function for resize recovery.
+     */
+    rerender: () => void;
+};
+/**
+ * Hook to track static output and provide re-render capability.
+ *
+ * Stores all output in a buffer (using ref to avoid re-renders on append).
+ * On resize, the rerender() function clears the terminal and writes
+ * all buffered content, restoring the display.
+ */
+export declare function useStaticOutputBuffer(): UseStaticOutputBufferResult;

package/dist/common/hooks/useStaticOutputBuffer.js

@@ -0,0 +1,58 @@
+import { useRef, useCallback } from 'react';
+import { useStdout } from 'ink';
+/**
+ * ANSI escape sequences for terminal control.
+ */
+const ANSI = {
+    /** Clear visible screen */
+    CLEAR_SCREEN: '\x1B[2J',
+    /** Clear scrollback buffer */
+    CLEAR_SCROLLBACK: '\x1B[3J',
+    /** Move cursor to top-left */
+    CURSOR_HOME: '\x1B[H',
+};
+/**
+ * Hook to track static output and provide re-render capability.
+ *
+ * Stores all output in a buffer (using ref to avoid re-renders on append).
+ * On resize, the rerender() function clears the terminal and writes
+ * all buffered content, restoring the display.
+ */
+export function useStaticOutputBuffer() {
+    const { stdout } = useStdout();
+    const bufferRef = useRef([]);
+    const appendOutput = useCallback((id, content) => {
+        // Check if item already exists (by id)
+        const exists = bufferRef.current.some(item => item.id === id);
+        if (!exists) {
+            bufferRef.current.push({ id, content });
+        }
+    }, []);
+    const clearOutput = useCallback(() => {
+        bufferRef.current = [];
+    }, []);
+    const getBufferSize = useCallback(() => {
+        return bufferRef.current.length;
+    }, []);
+    const getFullBuffer = useCallback(() => {
+        return bufferRef.current.map(item => item.content).join('\n');
+    }, []);
+    const rerender = useCallback(() => {
+        if (!stdout)
+            return;
+        const fullContent = getFullBuffer();
+        // Only clear and rewrite if we have content to restore
+        // Otherwise we'd just blank the screen for no reason
+        if (!fullContent.trim())
+            return;
+        // Clear screen and scrollback, move cursor home, write all content
+        stdout.write(ANSI.CLEAR_SCREEN + ANSI.CLEAR_SCROLLBACK + ANSI.CURSOR_HOME + fullContent);
+    }, [stdout, getFullBuffer]);
+    return {
+        appendOutput,
+        clearOutput,
+        getBufferSize,
+        getFullBuffer,
+        rerender,
+    };
+}

package/dist/common/hooks/useTerminalResize.d.ts

@@ -0,0 +1,28 @@
+import type { TerminalDimensions } from '../types.js';
+export type UseTerminalResizeOptions = {
+    /**
+     * Callback invoked on resize (after debounce).
+     */
+    onResize?: (dimensions: TerminalDimensions, previousDimensions: TerminalDimensions | null) => void;
+    /**
+     * Debounce delay in milliseconds. Default: 50
+     */
+    debounceMs?: number;
+};
+export type UseTerminalResizeResult = {
+    /**
+     * Current terminal dimensions.
+     */
+    dimensions: TerminalDimensions;
+    /**
+     * Previous terminal dimensions (null on first render).
+     */
+    previousDimensions: TerminalDimensions | null;
+};
+/**
+ * Hook to detect terminal resize events.
+ *
+ * Subscribes to stdout 'resize' events and provides current/previous dimensions.
+ * Debounces rapid resize events to avoid excessive re-renders.
+ */
+export declare function useTerminalResize(options?: UseTerminalResizeOptions): UseTerminalResizeResult;

package/dist/common/hooks/useTerminalResize.js

@@ -0,0 +1,51 @@
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { useStdout } from 'ink';
+/**
+ * Hook to detect terminal resize events.
+ *
+ * Subscribes to stdout 'resize' events and provides current/previous dimensions.
+ * Debounces rapid resize events to avoid excessive re-renders.
+ */
+export function useTerminalResize(options = {}) {
+    const { onResize, debounceMs = 50 } = options;
+    const { stdout } = useStdout();
+    const getDimensions = useCallback(() => {
+        return {
+            rows: stdout?.rows ?? 24,
+            columns: stdout?.columns ?? 80,
+        };
+    }, [stdout]);
+    const [dimensions, setDimensions] = useState(getDimensions);
+    const [previousDimensions, setPreviousDimensions] = useState(null);
+    const debounceTimerRef = useRef(null);
+    const onResizeRef = useRef(onResize);
+    // Keep callback ref up to date
+    useEffect(() => {
+        onResizeRef.current = onResize;
+    }, [onResize]);
+    useEffect(() => {
+        const handleResize = () => {
+            // Clear any pending debounce
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+            debounceTimerRef.current = setTimeout(() => {
+                const newDimensions = getDimensions();
+                setDimensions(prev => {
+                    setPreviousDimensions(prev);
+                    onResizeRef.current?.(newDimensions, prev);
+                    return newDimensions;
+                });
+                debounceTimerRef.current = null;
+            }, debounceMs);
+        };
+        process.stdout.on('resize', handleResize);
+        return () => {
+            process.stdout.off('resize', handleResize);
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+    }, [getDimensions, debounceMs]);
+    return { dimensions, previousDimensions };
+}

package/dist/common/hooks/useTextBuffer.d.ts

@@ -0,0 +1,13 @@
+import type { TextBufferState } from '../types.js';
+export declare function useTextBuffer(): {
+    state: TextBufferState;
+    insertChar: (char: string) => void;
+    insertNewline: () => void;
+    deleteChar: () => void;
+    deleteCharBefore: () => void;
+    moveCursor: (direction: "left" | "right" | "up" | "down") => void;
+    clear: () => void;
+    setText: (text: string) => void;
+    getText: () => string;
+    isEmpty: () => boolean;
+};

package/dist/common/hooks/useTextBuffer.js

@@ -0,0 +1,165 @@
+import { useState, useCallback } from 'react';
+export function useTextBuffer() {
+    const [state, setState] = useState({
+        lines: [''],
+        cursorLine: 0,
+        cursorCol: 0,
+    });
+    const insertChar = useCallback((char) => {
+        setState(prev => {
+            const newLines = [...prev.lines];
+            const line = newLines[prev.cursorLine] ?? '';
+            newLines[prev.cursorLine] =
+                line.slice(0, prev.cursorCol) + char + line.slice(prev.cursorCol);
+            return {
+                ...prev,
+                lines: newLines,
+                cursorCol: prev.cursorCol + char.length,
+            };
+        });
+    }, []);
+    const insertNewline = useCallback(() => {
+        setState(prev => {
+            const newLines = [...prev.lines];
+            const line = newLines[prev.cursorLine] ?? '';
+            const before = line.slice(0, prev.cursorCol);
+            const after = line.slice(prev.cursorCol);
+            newLines[prev.cursorLine] = before;
+            newLines.splice(prev.cursorLine + 1, 0, after);
+            return {
+                lines: newLines,
+                cursorLine: prev.cursorLine + 1,
+                cursorCol: 0,
+            };
+        });
+    }, []);
+    const deleteChar = useCallback(() => {
+        setState(prev => {
+            if (prev.cursorCol === 0 && prev.cursorLine === 0)
+                return prev;
+            const newLines = [...prev.lines];
+            if (prev.cursorCol === 0) {
+                // Merge with previous line
+                const currentLine = newLines[prev.cursorLine] ?? '';
+                const prevLineLen = (newLines[prev.cursorLine - 1] ?? '').length;
+                newLines[prev.cursorLine - 1] =
+                    (newLines[prev.cursorLine - 1] ?? '') + currentLine;
+                newLines.splice(prev.cursorLine, 1);
+                return {
+                    lines: newLines,
+                    cursorLine: prev.cursorLine - 1,
+                    cursorCol: prevLineLen,
+                };
+            }
+            else {
+                // Delete character before cursor
+                const line = newLines[prev.cursorLine] ?? '';
+                newLines[prev.cursorLine] =
+                    line.slice(0, prev.cursorCol - 1) + line.slice(prev.cursorCol);
+                return {
+                    ...prev,
+                    lines: newLines,
+                    cursorCol: prev.cursorCol - 1,
+                };
+            }
+        });
+    }, []);
+    // Delete single character before cursor (for backslash+enter handling)
+    const deleteCharBefore = useCallback(() => {
+        setState(prev => {
+            if (prev.cursorCol === 0)
+                return prev; // Nothing before cursor on this line
+            const newLines = [...prev.lines];
+            const line = newLines[prev.cursorLine] ?? '';
+            newLines[prev.cursorLine] =
+                line.slice(0, prev.cursorCol - 1) + line.slice(prev.cursorCol);
+            return {
+                ...prev,
+                lines: newLines,
+                cursorCol: prev.cursorCol - 1,
+            };
+        });
+    }, []);
+    const moveCursor = useCallback((direction) => {
+        setState(prev => {
+            switch (direction) {
+                case 'left':
+                    if (prev.cursorCol > 0) {
+                        return { ...prev, cursorCol: prev.cursorCol - 1 };
+                    }
+                    else if (prev.cursorLine > 0) {
+                        const prevLineLen = (prev.lines[prev.cursorLine - 1] ?? '')
+                            .length;
+                        return {
+                            ...prev,
+                            cursorLine: prev.cursorLine - 1,
+                            cursorCol: prevLineLen,
+                        };
+                    }
+                    return prev;
+                case 'right': {
+                    const lineLen = (prev.lines[prev.cursorLine] ?? '').length;
+                    if (prev.cursorCol < lineLen) {
+                        return { ...prev, cursorCol: prev.cursorCol + 1 };
+                    }
+                    else if (prev.cursorLine < prev.lines.length - 1) {
+                        return { ...prev, cursorLine: prev.cursorLine + 1, cursorCol: 0 };
+                    }
+                    return prev;
+                }
+                case 'up':
+                    if (prev.cursorLine > 0) {
+                        const newLineLen = (prev.lines[prev.cursorLine - 1] ?? '').length;
+                        return {
+                            ...prev,
+                            cursorLine: prev.cursorLine - 1,
+                            cursorCol: Math.min(prev.cursorCol, newLineLen),
+                        };
+                    }
+                    return prev;
+                case 'down':
+                    if (prev.cursorLine < prev.lines.length - 1) {
+                        const newLineLen = (prev.lines[prev.cursorLine + 1] ?? '').length;
+                        return {
+                            ...prev,
+                            cursorLine: prev.cursorLine + 1,
+                            cursorCol: Math.min(prev.cursorCol, newLineLen),
+                        };
+                    }
+                    return prev;
+                default:
+                    return prev;
+            }
+        });
+    }, []);
+    const clear = useCallback(() => {
+        setState({ lines: [''], cursorLine: 0, cursorCol: 0 });
+    }, []);
+    const setText = useCallback((text) => {
+        const lines = text.split('\n');
+        const lastLine = lines[lines.length - 1] ?? '';
+        setState({
+            lines,
+            cursorLine: lines.length - 1,
+            cursorCol: lastLine.length,
+        });
+    }, []);
+    const getText = useCallback(() => {
+        return state.lines.join('\n');
+    }, [state.lines]);
+    const isEmpty = useCallback(() => {
+        return state.lines.length === 1 && state.lines[0] === '';
+    }, [state.lines]);
+    return {
+        state,
+        insertChar,
+        insertNewline,
+        deleteChar,
+        deleteCharBefore,
+        moveCursor,
+        clear,
+        setText,
+        getText,
+        isEmpty,
+    };
+}

package/dist/common/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Common infrastructure for React/Ink CLI applications.
+ * Generic components and hooks with no RAG-specific dependencies.
+ */
+export * from './types.js';
+export { default as TextInput } from './components/TextInput.js';
+export { default as StatusBar } from './components/StatusBar.js';
+export { default as CommandSuggestions } from './components/CommandSuggestions.js';
+export { useCtrlC } from './hooks/useCtrlC.js';
+export { useCommandHistory } from './hooks/useCommandHistory.js';
+export { useTextBuffer } from './hooks/useTextBuffer.js';
+export { useKittyKeyboard } from './hooks/useKittyKeyboard.js';
+export { setupVSCodeTerminal } from './commands/terminalSetup.js';

package/dist/common/index.js

@@ -0,0 +1,17 @@
+/**
+ * Common infrastructure for React/Ink CLI applications.
+ * Generic components and hooks with no RAG-specific dependencies.
+ */
+// Types
+export * from './types.js';
+// Components
+export { default as TextInput } from './components/TextInput.js';
+export { default as StatusBar } from './components/StatusBar.js';
+export { default as CommandSuggestions } from './components/CommandSuggestions.js';
+// Hooks
+export { useCtrlC } from './hooks/useCtrlC.js';
+export { useCommandHistory } from './hooks/useCommandHistory.js';
+export { useTextBuffer } from './hooks/useTextBuffer.js';
+export { useKittyKeyboard } from './hooks/useKittyKeyboard.js';
+// Commands
+export { setupVSCodeTerminal } from './commands/terminalSetup.js';

package/dist/common/types.d.ts

@@ -0,0 +1,162 @@
+/**
+ * A single search result item for display.
+ */
+export type SearchResultItem = {
+    type: string;
+    name: string;
+    filepath: string;
+    filename: string;
+    startLine: number;
+    endLine: number;
+    score: number;
+    text: string;
+};
+/**
+ * Search results data for display.
+ */
+export type SearchResultsData = {
+    query: string;
+    elapsedMs: number;
+    results: SearchResultItem[];
+};
+/**
+ * Output items for the CLI display.
+ */
+export type OutputItem = {
+    id: string;
+    type: 'user';
+    content: string;
+} | {
+    id: string;
+    type: 'system';
+    content: string;
+} | {
+    id: string;
+    type: 'welcome';
+    content: string;
+} | {
+    id: string;
+    type: 'search-results';
+    data: SearchResultsData;
+};
+/**
+ * Terminal dimensions for resize handling.
+ */
+export type TerminalDimensions = {
+    rows: number;
+    columns: number;
+};
+export type TextBufferState = {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+};
+/**
+ * App status for the status bar.
+ */
+export type AppStatus = {
+    state: 'ready';
+} | {
+    state: 'indexing';
+    current: number;
+    total: number;
+    stage: string;
+} | {
+    state: 'searching';
+} | {
+    state: 'warning';
+    message: string;
+};
+/**
+ * Index statistics for display.
+ */
+export type IndexDisplayStats = {
+    totalFiles: number;
+    totalChunks: number;
+};
+/**
+ * Embedding provider types.
+ *
+ * Local providers (no API key required):
+ * - local: Qwen3-Embedding-0.6B Q8 (1024d) - ~700MB download, ~1.2GB RAM
+ * - local-4b: Qwen3-Embedding-4B FP32 (2560d) - ~8GB download, ~8GB RAM
+ *
+ * API providers:
+ * - gemini: gemini-embedding-001 (768d) - Free tier
+ * - mistral: codestral-embed (1024d) - Code-optimized
+ * - openai: text-embedding-3-small (1536d) - Fast API
+ */
+export type EmbeddingProviderType = 'local' | 'local-4b' | 'gemini' | 'mistral' | 'openai';
+/**
+ * Configuration collected from the init wizard.
+ */
+export type InitWizardConfig = {
+    provider: EmbeddingProviderType;
+    /** API key for cloud providers (gemini, mistral, openai) */
+    apiKey?: string;
+};
+/**
+ * MCP editor identifiers.
+ */
+export type McpEditorId = 'claude-code' | 'vscode' | 'cursor' | 'windsurf' | 'roo-code' | 'zed' | 'gemini-cli' | 'codex' | 'jetbrains' | 'opencode';
+/**
+ * MCP setup result.
+ */
+export type McpSetupResultType = {
+    success: boolean;
+    editor: McpEditorId;
+    method: 'file-created' | 'file-merged' | 'cli-command' | 'instructions-shown';
+    configPath?: string;
+    error?: string;
+};
+/**
+ * Configuration collected from the MCP setup wizard.
+ */
+export type McpSetupWizardConfig = {
+    selectedEditors: McpEditorId[];
+    results: McpSetupResultType[];
+};
+/**
+ * MCP setup wizard step types.
+ */
+export type McpSetupStep = 'prompt' | 'select' | 'configure' | 'summary';
+/**
+ * Wizard mode state for the app.
+ */
+export type WizardMode = {
+    active: false;
+} | {
+    active: true;
+    type: 'init';
+    step: number;
+    config: Partial<InitWizardConfig>;
+    isReinit: boolean;
+} | {
+    active: true;
+    type: 'mcp-setup';
+    step: McpSetupStep;
+    config: Partial<McpSetupWizardConfig>;
+    showPrompt: boolean;
+} | {
+    active: true;
+    type: 'clean';
+};
+/**
+ * Provider configuration with model specs.
+ */
+export type ProviderConfig = {
+    name: string;
+    model: string;
+    dimensions: number;
+    context: string;
+    performance: string;
+    pricing: string;
+    description: string;
+};
+/**
+ * Command info for autocomplete with descriptions.
+ */
+export type CommandInfo = {
+    command: string;
+    description: string;
+};

package/dist/common/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * VibeRAG MCP Server Entry Point
+ *
+ * Exposes VibeRAG functionality via Model Context Protocol.
+ * Uses current working directory as project root.
+ * Includes file watcher for automatic incremental indexing.
+ *
+ * Usage with Claude Code:
+ *   claude mcp add viberag -- npx viberag-mcp
+ */
+export {};