viberag 0.3.2 → 0.4.0

package/dist/client/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Daemon Client
+ *
+ * High-level client for daemon communication.
+ * Provides typed API methods and handles connection lifecycle.
+ *
+ * Simplified for polling-based architecture:
+ * - Pure request/response, no push notifications
+ * - No reconnection logic - clients poll and reconnect as needed
+ * - Auto-starts daemon if not running
+ */
+import type { DaemonClientOptions, ClientSearchOptions, ClientIndexOptions, IndexStartResponse, DaemonStatusResponse, PingResponse, SearchResults, IndexStats, WatcherStatus } from './types.js';
+/**
+ * Client for communicating with the VibeRAG daemon.
+ * Pure request/response - clients poll status() for updates.
+ */
+export declare class DaemonClient {
+    private readonly projectRoot;
+    private readonly socketPath;
+    private readonly autoStart;
+    private readonly connectTimeout;
+    private connection;
+    private connectPromise;
+    constructor(options: DaemonClientOptions | string);
+    /**
+     * Check if connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to the daemon.
+     * Auto-starts daemon if not running (when autoStart is true).
+     * Safe for concurrent calls - will reuse in-flight connection attempt.
+     */
+    connect(): Promise<void>;
+    /**
+     * Internal connection logic.
+     */
+    private doConnect;
+    /**
+     * Disconnect from the daemon.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if daemon is running (without connecting).
+     */
+    isRunning(): Promise<boolean>;
+    /**
+     * Ensure connected before making a request.
+     */
+    private ensureConnected;
+    /**
+     * Search the codebase.
+     */
+    search(query: string, options?: ClientSearchOptions): Promise<SearchResults>;
+    /**
+     * Index the codebase.
+     */
+    index(options?: ClientIndexOptions): Promise<IndexStats>;
+    /**
+     * Start indexing asynchronously.
+     */
+    indexAsync(options?: ClientIndexOptions): Promise<IndexStartResponse>;
+    /**
+     * Get daemon status.
+     * Clients should poll this endpoint for state updates.
+     */
+    status(): Promise<DaemonStatusResponse>;
+    /**
+     * Get watcher status.
+     */
+    watchStatus(): Promise<WatcherStatus>;
+    /**
+     * Request daemon shutdown.
+     */
+    shutdown(reason?: string): Promise<void>;
+    /**
+     * Ping the daemon.
+     */
+    ping(): Promise<PingResponse>;
+    /**
+     * Get health information.
+     */
+    health(): Promise<{
+        healthy: boolean;
+        uptime: number;
+        memoryUsage: NodeJS.MemoryUsage;
+        clients: number;
+        indexStatus: string;
+        protocolVersion: number;
+    }>;
+}
+export { getSocketPath, getLockPath, isDaemonRunning, isDaemonLocked, } from './auto-start.js';
+export type { DaemonClientOptions, ClientSearchOptions, ClientIndexOptions, DaemonStatusResponse, PingResponse, SearchResults, IndexStats, WatcherStatus, SlotState, FailedChunk, } from './types.js';

package/dist/client/index.js

@@ -0,0 +1,209 @@
+/**
+ * Daemon Client
+ *
+ * High-level client for daemon communication.
+ * Provides typed API methods and handles connection lifecycle.
+ *
+ * Simplified for polling-based architecture:
+ * - Pure request/response, no push notifications
+ * - No reconnection logic - clients poll and reconnect as needed
+ * - Auto-starts daemon if not running
+ */
+import { DaemonConnection } from './connection.js';
+import { ensureDaemonRunning, isDaemonRunning, getSocketPath, } from './auto-start.js';
+// ============================================================================
+// DaemonClient
+// ============================================================================
+/**
+ * Client for communicating with the VibeRAG daemon.
+ * Pure request/response - clients poll status() for updates.
+ */
+export class DaemonClient {
+    constructor(options) {
+        Object.defineProperty(this, "projectRoot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "socketPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoStart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connectTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "connectPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Handle simple string constructor
+        if (typeof options === 'string') {
+            this.projectRoot = options;
+            this.autoStart = true;
+            this.connectTimeout = 5000;
+        }
+        else {
+            this.projectRoot = options.projectRoot;
+            this.autoStart = options.autoStart ?? true;
+            this.connectTimeout = options.connectTimeout ?? 5000;
+        }
+        this.socketPath = getSocketPath(this.projectRoot);
+    }
+    // ==========================================================================
+    // Connection Management
+    // ==========================================================================
+    /**
+     * Check if connected.
+     */
+    isConnected() {
+        return this.connection?.isConnected() === true;
+    }
+    /**
+     * Connect to the daemon.
+     * Auto-starts daemon if not running (when autoStart is true).
+     * Safe for concurrent calls - will reuse in-flight connection attempt.
+     */
+    async connect() {
+        if (this.isConnected()) {
+            return;
+        }
+        // Reuse existing connection attempt if one is in progress
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        this.connectPromise = this.doConnect();
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    /**
+     * Internal connection logic.
+     */
+    async doConnect() {
+        try {
+            // Auto-start daemon if needed
+            if (this.autoStart) {
+                await ensureDaemonRunning(this.projectRoot);
+            }
+            // Create connection
+            this.connection = new DaemonConnection(this.socketPath);
+            // Connect
+            await this.connection.connect(this.connectTimeout);
+        }
+        catch (error) {
+            this.connection = null;
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from the daemon.
+     */
+    async disconnect() {
+        if (this.connection) {
+            this.connection.disconnect();
+            this.connection = null;
+        }
+    }
+    /**
+     * Check if daemon is running (without connecting).
+     */
+    async isRunning() {
+        return isDaemonRunning(this.projectRoot);
+    }
+    // ==========================================================================
+    // API Methods
+    // ==========================================================================
+    /**
+     * Ensure connected before making a request.
+     */
+    async ensureConnected() {
+        if (!this.isConnected()) {
+            await this.connect();
+        }
+    }
+    /**
+     * Search the codebase.
+     */
+    async search(query, options) {
+        await this.ensureConnected();
+        return this.connection.request('search', {
+            query,
+            ...options,
+        });
+    }
+    /**
+     * Index the codebase.
+     */
+    async index(options) {
+        await this.ensureConnected();
+        return this.connection.request('index', options);
+    }
+    /**
+     * Start indexing asynchronously.
+     */
+    async indexAsync(options) {
+        await this.ensureConnected();
+        return this.connection.request('indexAsync', options);
+    }
+    /**
+     * Get daemon status.
+     * Clients should poll this endpoint for state updates.
+     */
+    async status() {
+        await this.ensureConnected();
+        return this.connection.request('status');
+    }
+    /**
+     * Get watcher status.
+     */
+    async watchStatus() {
+        await this.ensureConnected();
+        return this.connection.request('watchStatus');
+    }
+    /**
+     * Request daemon shutdown.
+     */
+    async shutdown(reason) {
+        await this.ensureConnected();
+        await this.connection.request('shutdown', { reason });
+    }
+    /**
+     * Ping the daemon.
+     */
+    async ping() {
+        await this.ensureConnected();
+        return this.connection.request('ping');
+    }
+    /**
+     * Get health information.
+     */
+    async health() {
+        await this.ensureConnected();
+        return this.connection.request('health');
+    }
+}
+// Re-export types and utilities
+export { getSocketPath, getLockPath, isDaemonRunning, isDaemonLocked, } from './auto-start.js';

package/dist/client/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Client Types
+ *
+ * Types for daemon client communication.
+ * Simplified for polling-based architecture.
+ */
+import type { SearchResults } from '../daemon/services/search/types.js';
+import type { IndexStats } from '../daemon/services/indexing.js';
+import type { WatcherStatus } from '../daemon/services/watcher.js';
+/**
+ * Slot state for concurrent embedding tracking.
+ */
+export interface SlotState {
+    state: 'idle' | 'processing' | 'rate-limited';
+    batchInfo: string | null;
+    retryInfo: string | null;
+}
+/**
+ * Failed chunk info.
+ */
+export interface FailedChunk {
+    batchInfo: string;
+    error: string;
+    timestamp: string;
+}
+/**
+ * Options for DaemonClient constructor.
+ */
+export interface DaemonClientOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Auto-start daemon if not running (default: true) */
+    autoStart?: boolean;
+    /** Connection timeout in ms (default: 5000) */
+    connectTimeout?: number;
+}
+/**
+ * Search options for client.
+ */
+export interface ClientSearchOptions {
+    mode?: 'semantic' | 'exact' | 'hybrid' | 'definition' | 'similar';
+    limit?: number;
+    bm25Weight?: number;
+    minScore?: number;
+    filters?: Record<string, unknown>;
+    codeSnippet?: string;
+    symbolName?: string;
+    autoBoost?: boolean;
+    autoBoostThreshold?: number;
+    returnDebug?: boolean;
+}
+/**
+ * Index options for client.
+ */
+export interface ClientIndexOptions {
+    force?: boolean;
+}
+/**
+ * Index start response for async indexing.
+ */
+export interface IndexStartResponse {
+    started: boolean;
+    reason?: 'in_progress';
+}
+/**
+ * Daemon status response.
+ * Enhanced to support polling-based state synchronization.
+ */
+export interface DaemonStatusResponse {
+    initialized: boolean;
+    indexed: boolean;
+    version?: number;
+    createdAt?: string;
+    updatedAt?: string;
+    totalFiles?: number;
+    totalChunks?: number;
+    embeddingProvider?: string;
+    embeddingModel?: string;
+    warmupStatus: string;
+    warmupElapsedMs?: number;
+    watcherStatus: WatcherStatus;
+    indexing: {
+        status: 'idle' | 'initializing' | 'indexing' | 'complete' | 'error';
+        current: number;
+        total: number;
+        stage: string;
+        chunksProcessed: number;
+        throttleMessage: string | null;
+        error: string | null;
+        lastCompleted: string | null;
+        lastStats: IndexStats | null;
+        percent: number;
+    };
+    slots: SlotState[];
+    failures: FailedChunk[];
+}
+/**
+ * Ping response.
+ */
+export interface PingResponse {
+    pong: boolean;
+    timestamp: number;
+    protocolVersion: number;
+}
+export type { SearchResults, IndexStats, WatcherStatus };

package/dist/client/types.js

@@ -0,0 +1,7 @@
+/**
+ * Client Types
+ *
+ * Types for daemon client communication.
+ * Simplified for polling-based architecture.
+ */
+export {};

package/dist/common/components/SlotRow.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Individual slot row component for displaying batch processing progress.
+ *
+ * Each SlotRow watches its own slice of Redux state and renders independently.
+ * This follows the Single Responsibility Principle - each row manages its own
+ * rendering logic based on its slot index.
+ */
+import React from 'react';
+type Props = {
+    /** The slot index (0 to CONCURRENCY-1) */
+    slotIndex: number;
+    /** Whether this is the last visible slot (for tree-drawing) */
+    isLast: boolean;
+};
+/**
+ * Renders a single slot's progress status.
+ *
+ * Always renders a fixed-height row to prevent UI jumping when slots
+ * become active/idle. Idle slots show an empty placeholder.
+ */
+export declare function SlotRow({ slotIndex, isLast }: Props): React.ReactElement;
+export {};

package/dist/common/components/SlotRow.js

@@ -0,0 +1,53 @@
+/**
+ * Individual slot row component for displaying batch processing progress.
+ *
+ * Each SlotRow watches its own slice of Redux state and renders independently.
+ * This follows the Single Responsibility Principle - each row manages its own
+ * rendering logic based on its slot index.
+ */
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { useAppSelector } from '../../store/hooks.js';
+import { selectSlot } from '../../store/slot-progress/selectors.js';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Braille dots spinner frames */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Renders a single slot's progress status.
+ *
+ * Always renders a fixed-height row to prevent UI jumping when slots
+ * become active/idle. Idle slots show an empty placeholder.
+ */
+export function SlotRow({ slotIndex, isLast }) {
+    const slot = useAppSelector(state => selectSlot(state, slotIndex));
+    const [frame, setFrame] = useState(0);
+    // Spinner animation - only runs when processing
+    useEffect(() => {
+        if (slot.state !== 'processing')
+            return;
+        const timer = setInterval(() => {
+            setFrame(f => (f + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, [slot.state]);
+    // Tree-drawing prefix
+    const prefix = isLast ? '└ ' : '├ ';
+    // Idle slots render empty placeholder to maintain fixed height
+    if (slot.state === 'idle') {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { dimColor: true }, prefix),
+            React.createElement(Text, { dimColor: true }, "\u00B7")));
+    }
+    return (React.createElement(Box, null,
+        React.createElement(Text, { dimColor: true }, prefix),
+        slot.state === 'rate-limited' ? (React.createElement(Text, { color: "yellow" },
+            "\u26A0 ",
+            slot.batchInfo,
+            slot.retryInfo && ` · ${slot.retryInfo}`)) : (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "cyan" },
+                SPINNER_FRAMES[frame],
+                " "),
+            React.createElement(Text, { dimColor: true }, slot.batchInfo)))));
+}

package/dist/common/components/StatusBar.js

@@ -1,5 +1,9 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text } from 'ink';
+import { useAppSelector } from '../../store/hooks.js';
+import { selectSlotCount, selectFailures, selectHasActiveSlots, } from '../../store/slot-progress/selectors.js';
+import { selectIndexingDisplay, selectIsIndexing, } from '../../store/indexing/selectors.js';
+import { SlotRow } from './SlotRow.js';
 /** Braille dots spinner frames */
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 /**
@@ -17,37 +21,25 @@ function Spinner({ color }) {
         SPINNER_FRAMES[frame],
         " ");
 }
+/**
+ * Progress bar component for visual progress indication.
+ */
+function ProgressBar({ percent, width = 20, }) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return (React.createElement(Text, null,
+        React.createElement(Text, { color: "cyan" }, '█'.repeat(filled)),
+        React.createElement(Text, { dimColor: true }, '░'.repeat(empty))));
+}
 /**
  * Format status message for display.
+ * Note: Indexing state is derived from Redux via selectIsIndexing.
+ * This function only handles non-indexing app states.
  */
-function formatStatus(status) {
+function formatNonIndexingStatus(status) {
     switch (status.state) {
         case 'ready':
             return { text: 'Ready', color: 'green', showSpinner: false };
-        case 'indexing': {
-            // Throttle status takes precedence - show in yellow
-            if (status.throttleMessage) {
-                return {
-                    text: status.throttleMessage,
-                    color: 'yellow',
-                    showSpinner: true,
-                };
-            }
-            // Normal indexing display
-            if (status.total === 0) {
-                return { text: `${status.stage}`, color: 'cyan', showSpinner: true };
-            }
-            const percent = Math.round((status.current / status.total) * 100);
-            // Include chunk count if available
-            const chunkInfo = status.chunksProcessed !== undefined
-                ? ` · ${status.chunksProcessed} chunks`
-                : '';
-            return {
-                text: `${status.stage} ${status.current}/${status.total} (${percent}%)${chunkInfo}`,
-                color: 'cyan',
-                showSpinner: true,
-            };
-        }
         case 'searching':
             return { text: 'Searching', color: 'cyan', showSpinner: true };
         case 'warning':
@@ -67,11 +59,70 @@ function formatStats(stats) {
     return `${stats.totalFiles} files · ${stats.totalChunks} chunks`;
 }
 export default function StatusBar({ status, stats }) {
-    const { text, color, showSpinner } = formatStatus(status);
     const statsText = formatStats(stats);
-    return (React.createElement(Box, { paddingX: 1, justifyContent: "space-between" },
-        React.createElement(Box, null,
-            showSpinner && React.createElement(Spinner, { color: color }),
-            React.createElement(Text, { color: color }, text)),
-        React.createElement(Text, { dimColor: true }, statsText)));
+    // Redux selectors for indexing progress
+    const indexingDisplay = useAppSelector(selectIndexingDisplay);
+    const isIndexingActive = useAppSelector(selectIsIndexing);
+    // Redux selectors for slot progress
+    const slotCount = useAppSelector(selectSlotCount);
+    const failures = useAppSelector(selectFailures);
+    const hasActiveSlots = useAppSelector(selectHasActiveSlots);
+    // Determine display values based on state source
+    // For indexing: use Redux state (synced from daemon - single source of truth)
+    // For other states: use props (local app state)
+    const nonIndexingStatus = formatNonIndexingStatus(status);
+    // Use Redux for indexing display, props for everything else
+    const displayValues = isIndexingActive
+        ? {
+            text: indexingDisplay.stage,
+            color: indexingDisplay.color,
+            showSpinner: true,
+            showProgressBar: indexingDisplay.showProgressBar,
+            percent: indexingDisplay.percent,
+            stage: indexingDisplay.stage,
+            chunkInfo: indexingDisplay.chunkInfo,
+            throttleInfo: indexingDisplay.throttleInfo,
+        }
+        : {
+            text: nonIndexingStatus.text,
+            color: nonIndexingStatus.color,
+            showSpinner: nonIndexingStatus.showSpinner,
+            showProgressBar: false,
+            percent: 0,
+            stage: '',
+            chunkInfo: undefined,
+            throttleInfo: null,
+        };
+    const { text, color, showSpinner, showProgressBar, percent, stage, chunkInfo, throttleInfo, } = displayValues;
+    // Only show slots when there's actual activity (API providers use slots, local doesn't)
+    const showSlots = isIndexingActive && hasActiveSlots;
+    // Show failure summary if any batches failed
+    const hasFailures = failures.length > 0;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { paddingX: 1, justifyContent: "space-between" },
+            React.createElement(Box, null,
+                showSpinner && React.createElement(Spinner, { color: color }),
+                showProgressBar ? (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: color },
+                        stage,
+                        " "),
+                    React.createElement(Text, null, "["),
+                    React.createElement(ProgressBar, { percent: percent }),
+                    React.createElement(Text, null, "] "),
+                    React.createElement(Text, { color: color },
+                        percent,
+                        "%"),
+                    chunkInfo && React.createElement(Text, { dimColor: true },
+                        " \u00B7 ",
+                        chunkInfo),
+                    throttleInfo && React.createElement(Text, { color: "yellow" },
+                        " \u00B7 ",
+                        throttleInfo))) : (React.createElement(Text, { color: color }, text))),
+            React.createElement(Text, { dimColor: true }, statsText)),
+        showSlots && (React.createElement(Box, { flexDirection: "column", paddingLeft: 2 }, Array.from({ length: slotCount }, (_, i) => (React.createElement(SlotRow, { key: i, slotIndex: i, isLast: i === slotCount - 1 }))))),
+        hasFailures && (React.createElement(Box, { paddingLeft: 2 },
+            React.createElement(Text, { color: "red" },
+                "\u26A0 ",
+                failures.length,
+                " batch(es) failed - see .viberag/debug.log")))));
 }

package/dist/common/types.d.ts

@@ -53,18 +53,12 @@ export type TextBufferState = {
 };
 /**
  * App status for the status bar.
+ *
+ * Note: Indexing state is derived from the indexing Redux slice (synced from daemon).
+ * Do NOT use appStatus for indexing - use selectIsIndexing() instead.
  */
 export type AppStatus = {
     state: 'ready';
-} | {
-    state: 'indexing';
-    current: number;
-    total: number;
-    stage: string;
-    /** Rate limit message (shown in yellow when set) */
-    throttleMessage?: string | null;
-    /** Number of chunks embedded so far */
-    chunksProcessed?: number;
 } | {
     state: 'searching';
 } | {
@@ -81,16 +75,19 @@ export type IndexDisplayStats = {
 /**
  * Embedding provider types.
  *
- * Local providers (no API key required):
+ * Local provider (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 (1536d) - Free tier
  * - mistral: codestral-embed (1536d) - Code-optimized
- * - openai: text-embedding-3-small (1536d) - Fast API
+ * - openai: text-embedding-3-large (1536d) - Highest quality
+ */
+export type EmbeddingProviderType = 'local' | 'gemini' | 'mistral' | 'openai';
+/**
+ * OpenAI API regional endpoints for data residency.
  */
-export type EmbeddingProviderType = 'local' | 'local-4b' | 'gemini' | 'mistral' | 'openai';
+export type OpenAIRegion = 'default' | 'us' | 'eu';
 /**
  * Configuration collected from the init wizard.
  */
@@ -98,6 +95,8 @@ export type InitWizardConfig = {
     provider: EmbeddingProviderType;
     /** API key for cloud providers (gemini, mistral, openai) */
     apiKey?: string;
+    /** OpenAI regional endpoint (for corporate accounts with data residency) */
+    openaiRegion?: OpenAIRegion;
 };
 /**
  * MCP editor identifiers.