viberag 0.3.2 → 0.4.0

package/dist/daemon/lib/gitignore.js

@@ -0,0 +1,246 @@
+/**
+ * Gitignore - File filtering based on .gitignore patterns.
+ *
+ * Uses the `ignore` package to parse .gitignore files and filter paths.
+ * This replaces the hardcoded excludePatterns approach.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+// ignore is a CJS module, use createRequire to import it
+const require = createRequire(import.meta.url);
+const ignore = require('ignore');
+// ============================================================================
+// Always-Ignored Patterns
+// ============================================================================
+/**
+ * Patterns that should always be ignored, regardless of .gitignore.
+ * These are internal/system directories that should never be indexed.
+ */
+const ALWAYS_IGNORED = [
+    '.git',
+    '.viberag',
+    'node_modules', // Fallback in case not in .gitignore
+];
+/**
+ * Lock files that should always be ignored.
+ * These are machine-generated and provide no value for code search.
+ */
+const ALWAYS_IGNORED_FILES = [
+    // JavaScript/TypeScript
+    'package-lock.json', // npm
+    'yarn.lock', // Yarn
+    'pnpm-lock.yaml', // pnpm
+    'bun.lockb', // Bun
+    // Python
+    'uv.lock', // UV
+    'poetry.lock', // Poetry
+    'Pipfile.lock', // Pipenv
+    // Ruby
+    'Gemfile.lock', // Bundler
+    // PHP
+    'composer.lock', // Composer
+    // Rust
+    'Cargo.lock', // Cargo
+    // Go
+    'go.sum', // Go modules
+    // Java/Kotlin
+    'gradle.lockfile', // Gradle
+    // C#/.NET
+    'packages.lock.json', // NuGet
+    // Dart
+    'pubspec.lock', // Pub
+    // Swift
+    'Package.resolved', // Swift PM
+];
+/**
+ * File patterns that should always be ignored.
+ * These are build artifacts with no semantic value for code search.
+ */
+const ALWAYS_IGNORED_PATTERNS = [
+    '*.min.js', // Minified JavaScript
+    '*.min.css', // Minified CSS
+    '*.map', // Source maps
+    '*.d.ts.map', // TypeScript declaration maps
+];
+// ============================================================================
+// Cache
+// ============================================================================
+/**
+ * Cache of Ignore instances per project root.
+ */
+const ignoreCache = new Map();
+// ============================================================================
+// Core Functions
+// ============================================================================
+/**
+ * Load and parse .gitignore file from project root.
+ * Returns an Ignore instance that can filter paths.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Ignore instance for filtering
+ */
+export async function loadGitignore(projectRoot) {
+    // Check cache first
+    const cached = ignoreCache.get(projectRoot);
+    if (cached) {
+        return cached;
+    }
+    const ig = ignore();
+    // Add always-ignored patterns (directories)
+    ig.add(ALWAYS_IGNORED);
+    // Add always-ignored files (lock files)
+    ig.add(ALWAYS_IGNORED_FILES);
+    // Add always-ignored file patterns (minified, maps)
+    ig.add(ALWAYS_IGNORED_PATTERNS);
+    // Try to load .gitignore
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        ig.add(content);
+    }
+    catch {
+        // .gitignore doesn't exist, that's fine
+    }
+    // Cache the instance
+    ignoreCache.set(projectRoot, ig);
+    return ig;
+}
+/**
+ * Check if a path should be ignored based on .gitignore rules.
+ *
+ * @param projectRoot - Project root directory
+ * @param relativePath - Path relative to project root
+ * @returns true if the path should be ignored
+ */
+export async function shouldIgnore(projectRoot, relativePath) {
+    const ig = await loadGitignore(projectRoot);
+    return ig.ignores(relativePath);
+}
+/**
+ * Create a filter function for use with file listing.
+ * The filter returns true for files that should be INCLUDED (not ignored).
+ *
+ * @param projectRoot - Project root directory
+ * @returns Filter function that returns true for non-ignored files
+ */
+export async function createGitignoreFilter(projectRoot) {
+    const ig = await loadGitignore(projectRoot);
+    return (relativePath) => !ig.ignores(relativePath);
+}
+// ============================================================================
+// Cache Management
+// ============================================================================
+/**
+ * Clear the cache for a specific project root.
+ * Call this if .gitignore has been modified.
+ *
+ * @param projectRoot - Project root directory
+ */
+export function clearGitignoreCache(projectRoot) {
+    ignoreCache.delete(projectRoot);
+}
+/**
+ * Clear all cached Ignore instances.
+ */
+export function clearAllGitignoreCache() {
+    ignoreCache.clear();
+}
+// ============================================================================
+// Glob Pattern Conversion
+// ============================================================================
+/**
+ * Convert gitignore patterns to fast-glob ignore patterns.
+ * This allows fast-glob to skip directories upfront instead of
+ * scanning them and filtering later.
+ *
+ * @param projectRoot - Project root directory
+ * @returns Array of fast-glob compatible ignore patterns
+ */
+export async function getGlobIgnorePatterns(projectRoot) {
+    const patterns = [];
+    // Always exclude these directories (same as ALWAYS_IGNORED)
+    patterns.push('**/.git/**', '**/.viberag/**', '**/node_modules/**');
+    // Always exclude lock files (same as ALWAYS_IGNORED_FILES)
+    for (const file of ALWAYS_IGNORED_FILES) {
+        patterns.push(`**/${file}`);
+    }
+    // Always exclude file patterns (minified, maps)
+    for (const pattern of ALWAYS_IGNORED_PATTERNS) {
+        patterns.push(`**/${pattern}`);
+    }
+    // Try to load .gitignore
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip empty lines and comments
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            // Skip negation patterns (fast-glob handles these differently)
+            if (trimmed.startsWith('!')) {
+                continue;
+            }
+            // Convert gitignore pattern to fast-glob pattern
+            const globPattern = gitignoreToGlob(trimmed);
+            if (globPattern) {
+                patterns.push(globPattern);
+            }
+        }
+    }
+    catch {
+        // .gitignore doesn't exist, that's fine
+    }
+    return patterns;
+}
+/**
+ * Convert a single gitignore pattern to a fast-glob pattern.
+ *
+ * Gitignore patterns:
+ * - `foo` matches `foo` anywhere
+ * - `foo/` matches directory `foo` anywhere
+ * - `/foo` matches `foo` only at root
+ * - `*.log` matches `*.log` anywhere
+ *
+ * Fast-glob patterns:
+ * - Need double-star-slash prefix to match anywhere
+ * - Need "/**" suffix to match directory contents
+ */
+function gitignoreToGlob(pattern) {
+    let result = pattern;
+    // Handle rooted patterns (start with /)
+    const isRooted = result.startsWith('/');
+    if (isRooted) {
+        result = result.slice(1);
+    }
+    // Handle directory patterns (end with /)
+    const isDirectory = result.endsWith('/');
+    if (isDirectory) {
+        result = result.slice(0, -1);
+    }
+    // Skip patterns that are already glob-like with **
+    const hasDoublestar = result.includes('**');
+    // Build the glob pattern
+    if (isRooted) {
+        // Rooted: match only at project root
+        result = isDirectory ? `${result}/**` : result;
+    }
+    else if (!hasDoublestar) {
+        // Non-rooted: match anywhere in tree
+        result = isDirectory ? `**/${result}/**` : `**/${result}`;
+        // If it doesn't look like a directory name (has extension or glob),
+        // don't add trailing /**
+        if (!isDirectory &&
+            (result.includes('.') || result.includes('*') || result.includes('?'))) {
+            // Keep as-is, it's likely a file pattern
+        }
+        else if (!isDirectory) {
+            // Bare name like "node_modules" - treat as directory
+            result = `**/${pattern}/**`;
+        }
+    }
+    return result;
+}

package/dist/daemon/lib/logger.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Logger - File-based logging with daily and hourly rotation.
+ *
+ * Provides multiple logger implementations:
+ * - createLogger: Daily log files in .viberag/logs/
+ * - createDebugLogger: Single debug.log file (deprecated)
+ * - createServiceLogger: Per-service hourly rotation
+ * - createNullLogger: No-op for testing
+ */
+import { type ServiceName } from './constants.js';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    debug(component: string, message: string, data?: object): void;
+    info(component: string, message: string, data?: object): void;
+    warn(component: string, message: string, data?: object): void;
+    error(component: string, message: string, error?: Error): void;
+}
+/**
+ * Get the path to today's log file.
+ */
+export declare function getLogPath(projectRoot: string): string;
+/**
+ * Create a logger that writes to daily log files.
+ * Log files are created in the .viberag/logs/ directory.
+ */
+export declare function createLogger(projectRoot: string): Logger;
+/**
+ * Create a no-op logger for testing or when logging is disabled.
+ */
+export declare function createNullLogger(): Logger;
+/**
+ * Create a debug logger that writes to .viberag/debug.log.
+ * This is always-on logging for troubleshooting.
+ * @deprecated Use createServiceLogger instead for per-service logging.
+ */
+export declare function createDebugLogger(projectRoot: string): Logger;
+/**
+ * Create a service-specific logger with hourly rotation.
+ *
+ * Logs are written to: .viberag/logs/{service}/YYYY-MM-DD-HH.log
+ *
+ * @param projectRoot - Project root directory
+ * @param service - Service name (daemon, mcp, cli, indexer)
+ *
+ * @example
+ * const logger = createServiceLogger('/path/to/project', 'daemon');
+ * logger.error('Handler', 'Request failed', error);
+ * // Writes to: .viberag/logs/daemon/2024-01-11-15.log
+ */
+export declare function createServiceLogger(projectRoot: string, service: ServiceName): Logger;
+export type { ServiceName };

package/dist/daemon/lib/logger.js

@@ -0,0 +1,167 @@
+/**
+ * Logger - File-based logging with daily and hourly rotation.
+ *
+ * Provides multiple logger implementations:
+ * - createLogger: Daily log files in .viberag/logs/
+ * - createDebugLogger: Single debug.log file (deprecated)
+ * - createServiceLogger: Per-service hourly rotation
+ * - createNullLogger: No-op for testing
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { getLogsDir, getDebugLogPath, getViberagDir, getServiceLogsDir, getServiceLogPath, } from './constants.js';
+// ============================================================================
+// Formatting
+// ============================================================================
+/**
+ * Get the path to today's log file.
+ */
+export function getLogPath(projectRoot) {
+    const logsDir = getLogsDir(projectRoot);
+    const date = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    return path.join(logsDir, `${date}.log`);
+}
+/**
+ * Format a log entry.
+ */
+function formatEntry(level, component, message, extra) {
+    const timestamp = new Date().toISOString();
+    const levelStr = level.toUpperCase().padEnd(5);
+    let entry = `[${timestamp}] [${levelStr}] ${component}: ${message}`;
+    if (extra) {
+        if (extra instanceof Error) {
+            entry += `\n  Error: ${extra.message}`;
+            if (extra.stack) {
+                entry += `\n  Stack: ${extra.stack}`;
+            }
+        }
+        else {
+            entry += `\n  ${JSON.stringify(extra)}`;
+        }
+    }
+    return entry;
+}
+// ============================================================================
+// Logger Implementations
+// ============================================================================
+/**
+ * Create a logger that writes to daily log files.
+ * Log files are created in the .viberag/logs/ directory.
+ */
+export function createLogger(projectRoot) {
+    const logsDir = getLogsDir(projectRoot);
+    let initialized = false;
+    function ensureDir() {
+        if (!initialized) {
+            fs.mkdirSync(logsDir, { recursive: true });
+            initialized = true;
+        }
+    }
+    function write(entry) {
+        ensureDir();
+        const logPath = getLogPath(projectRoot);
+        fs.appendFileSync(logPath, entry + '\n');
+    }
+    return {
+        debug(component, message, data) {
+            write(formatEntry('debug', component, message, data));
+        },
+        info(component, message, data) {
+            write(formatEntry('info', component, message, data));
+        },
+        warn(component, message, data) {
+            write(formatEntry('warn', component, message, data));
+        },
+        error(component, message, error) {
+            write(formatEntry('error', component, message, error));
+        },
+    };
+}
+/**
+ * Create a no-op logger for testing or when logging is disabled.
+ */
+export function createNullLogger() {
+    return {
+        debug() { },
+        info() { },
+        warn() { },
+        error() { },
+    };
+}
+/**
+ * Create a debug logger that writes to .viberag/debug.log.
+ * This is always-on logging for troubleshooting.
+ * @deprecated Use createServiceLogger instead for per-service logging.
+ */
+export function createDebugLogger(projectRoot) {
+    const viberagDir = getViberagDir(projectRoot);
+    let initialized = false;
+    function ensureDir() {
+        if (!initialized) {
+            fs.mkdirSync(viberagDir, { recursive: true });
+            initialized = true;
+        }
+    }
+    function write(entry) {
+        ensureDir();
+        const logPath = getDebugLogPath(projectRoot);
+        fs.appendFileSync(logPath, entry + '\n');
+    }
+    return {
+        debug(component, message, data) {
+            write(formatEntry('debug', component, message, data));
+        },
+        info(component, message, data) {
+            write(formatEntry('info', component, message, data));
+        },
+        warn(component, message, data) {
+            write(formatEntry('warn', component, message, data));
+        },
+        error(component, message, error) {
+            write(formatEntry('error', component, message, error));
+        },
+    };
+}
+/**
+ * Create a service-specific logger with hourly rotation.
+ *
+ * Logs are written to: .viberag/logs/{service}/YYYY-MM-DD-HH.log
+ *
+ * @param projectRoot - Project root directory
+ * @param service - Service name (daemon, mcp, cli, indexer)
+ *
+ * @example
+ * const logger = createServiceLogger('/path/to/project', 'daemon');
+ * logger.error('Handler', 'Request failed', error);
+ * // Writes to: .viberag/logs/daemon/2024-01-11-15.log
+ */
+export function createServiceLogger(projectRoot, service) {
+    function write(entry) {
+        try {
+            // Always ensure directory exists before writing
+            // (handles case where .viberag/ was deleted during reinit)
+            const serviceDir = getServiceLogsDir(projectRoot, service);
+            fs.mkdirSync(serviceDir, { recursive: true });
+            // Get current hourly log path (recalculated each write for rotation)
+            const logPath = getServiceLogPath(projectRoot, service);
+            fs.appendFileSync(logPath, entry + '\n');
+        }
+        catch {
+            // Silently ignore logging failures - don't crash the app for logging
+        }
+    }
+    return {
+        debug(component, message, data) {
+            write(formatEntry('debug', component, message, data));
+        },
+        info(component, message, data) {
+            write(formatEntry('info', component, message, data));
+        },
+        warn(component, message, data) {
+            write(formatEntry('warn', component, message, data));
+        },
+        error(component, message, error) {
+            write(formatEntry('error', component, message, error));
+        },
+    };
+}

package/dist/daemon/lib/manifest.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Manifest - Index manifest for tracking Merkle tree and stats.
+ *
+ * The manifest persists indexing state between runs:
+ * - Merkle tree for incremental change detection
+ * - Stats for status display
+ * - Schema version for migration detection
+ */
+export interface ManifestStats {
+    totalFiles: number;
+    totalChunks: number;
+}
+export interface Manifest {
+    version: number;
+    schemaVersion: number;
+    createdAt: string;
+    updatedAt: string;
+    tree: object | null;
+    stats: ManifestStats;
+}
+/**
+ * Create an empty manifest with current schema version.
+ */
+export declare function createEmptyManifest(): Manifest;
+/**
+ * Check if manifest schema version is current.
+ */
+export declare function isSchemaVersionCurrent(manifest: Manifest): boolean;
+/**
+ * Get schema version mismatch info for display.
+ */
+export declare function getSchemaVersionInfo(manifest: Manifest): {
+    current: number;
+    required: number;
+    needsReindex: boolean;
+};
+/**
+ * Load manifest from disk.
+ * Returns an empty manifest if no file exists.
+ */
+export declare function loadManifest(projectRoot: string): Promise<Manifest>;
+/**
+ * Save manifest to disk.
+ * Creates the .viberag directory if it doesn't exist.
+ */
+export declare function saveManifest(projectRoot: string, manifest: Manifest): Promise<void>;
+/**
+ * Check if a manifest file exists.
+ */
+export declare function manifestExists(projectRoot: string): Promise<boolean>;
+/**
+ * Update manifest stats.
+ */
+export declare function updateManifestStats(manifest: Manifest, stats: ManifestStats): Manifest;
+/**
+ * Update manifest tree.
+ */
+export declare function updateManifestTree(manifest: Manifest, tree: object | null): Manifest;

package/dist/daemon/lib/manifest.js

@@ -0,0 +1,116 @@
+/**
+ * Manifest - Index manifest for tracking Merkle tree and stats.
+ *
+ * The manifest persists indexing state between runs:
+ * - Merkle tree for incremental change detection
+ * - Stats for status display
+ * - Schema version for migration detection
+ */
+import fs from 'node:fs/promises';
+import { getManifestPath, getViberagDir, SCHEMA_VERSION } from './constants.js';
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create an empty manifest with current schema version.
+ */
+export function createEmptyManifest() {
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        schemaVersion: SCHEMA_VERSION,
+        createdAt: now,
+        updatedAt: now,
+        tree: null,
+        stats: {
+            totalFiles: 0,
+            totalChunks: 0,
+        },
+    };
+}
+// ============================================================================
+// Schema Version
+// ============================================================================
+/**
+ * Check if manifest schema version is current.
+ */
+export function isSchemaVersionCurrent(manifest) {
+    return manifest.schemaVersion === SCHEMA_VERSION;
+}
+/**
+ * Get schema version mismatch info for display.
+ */
+export function getSchemaVersionInfo(manifest) {
+    return {
+        current: manifest.schemaVersion ?? 1, // Default to 1 for old manifests
+        required: SCHEMA_VERSION,
+        needsReindex: (manifest.schemaVersion ?? 1) < SCHEMA_VERSION,
+    };
+}
+// ============================================================================
+// I/O
+// ============================================================================
+/**
+ * Load manifest from disk.
+ * Returns an empty manifest if no file exists.
+ */
+export async function loadManifest(projectRoot) {
+    const manifestPath = getManifestPath(projectRoot);
+    try {
+        const content = await fs.readFile(manifestPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return createEmptyManifest();
+    }
+}
+/**
+ * Save manifest to disk.
+ * Creates the .viberag directory if it doesn't exist.
+ */
+export async function saveManifest(projectRoot, manifest) {
+    const viberagDir = getViberagDir(projectRoot);
+    await fs.mkdir(viberagDir, { recursive: true });
+    const manifestPath = getManifestPath(projectRoot);
+    const updated = {
+        ...manifest,
+        updatedAt: new Date().toISOString(),
+    };
+    await fs.writeFile(manifestPath, JSON.stringify(updated, null, '\t') + '\n');
+}
+/**
+ * Check if a manifest file exists.
+ */
+export async function manifestExists(projectRoot) {
+    const manifestPath = getManifestPath(projectRoot);
+    try {
+        await fs.access(manifestPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Updates
+// ============================================================================
+/**
+ * Update manifest stats.
+ */
+export function updateManifestStats(manifest, stats) {
+    return {
+        ...manifest,
+        stats,
+        updatedAt: new Date().toISOString(),
+    };
+}
+/**
+ * Update manifest tree.
+ */
+export function updateManifestTree(manifest, tree) {
+    return {
+        ...manifest,
+        tree,
+        updatedAt: new Date().toISOString(),
+    };
+}

package/dist/daemon/lib/merkle/diff.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Merkle Diff - Tree comparison for change detection.
+ *
+ * Compares two Merkle trees to find new, modified, and deleted files.
+ * Uses hash comparison for efficient subtree comparison.
+ */
+import type { MerkleNode } from './node.js';
+/**
+ * Result of comparing two Merkle trees.
+ */
+export interface TreeDiff {
+    /** Paths of new files */
+    new: string[];
+    /** Paths of modified files */
+    modified: string[];
+    /** Paths of deleted files */
+    deleted: string[];
+    /** Whether there are any changes */
+    hasChanges: boolean;
+}
+/**
+ * Create an empty TreeDiff.
+ */
+export declare function createEmptyDiff(): TreeDiff;
+/**
+ * Compare two Merkle trees and return the differences.
+ *
+ * @param oldRoot - The previous tree's root node (or null if no previous tree)
+ * @param newRoot - The current tree's root node
+ * @returns TreeDiff with new, modified, and deleted file paths
+ */
+export declare function compareTrees(oldRoot: MerkleNode | null, newRoot: MerkleNode | null): TreeDiff;