@wildcard-ai/deepcontext/dist/services/ConfigurationService.d.ts

Advanced codebase indexing and semantic search MCP server

/**
 * Configuration Service
 * Handles application configuration, environment variables, and service validation
 */
export interface SearchConfig {
    defaultVectorWeight: number;
    defaultBm25Weight: number;
    defaultResultLimit: number;
}
export interface ChunkingConfig {
    maxChunkSize: number;
    treeSitterLimit: number;
    jinaMaxChars: number;
    semanticContextMargin: number;
}
export interface ProcessingConfig {
    maxAgeHours: number;
    batchSize: number;
    batchDelayMs: number;
}
export interface McpConfig {
    wildcardApiKey: string;
    jinaApiKey: string;
    turbopufferApiKey: string;
    logLevel: 'debug' | 'info' | 'warn' | 'error';
    search: SearchConfig;
    chunking: ChunkingConfig;
    processing: ProcessingConfig;
}
export interface ServiceCapabilities {
    reranking: boolean;
    vectorSearch: boolean;
    embedding: boolean;
}
export interface ConfigValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    capabilities: ServiceCapabilities;
}
export interface ConfigurationOptions {
    validateOnLoad?: boolean;
    logConfigurationStatus?: boolean;
    allowTestKeys?: boolean;
}
export declare class ConfigurationService {
    private logger;
    private config;
    private validationResult;
    constructor(configOverride?: Partial<McpConfig>, options?: ConfigurationOptions, loggerName?: string);
    /**
     * Load configuration from environment variables and overrides
     */
    private loadConfig;
    /**
     * Get the current configuration
     */
    getConfig(): Readonly<McpConfig>;
    /**
     * Update configuration
     */
    updateConfig(updates: Partial<McpConfig>, revalidate?: boolean): void;
    /**
     * Validate the current configuration
     */
    validateConfiguration(allowTestKeys?: boolean): ConfigValidationResult;
    /**
     * Get the last validation result
     */
    getValidationResult(): ConfigValidationResult | null;
    /**
     * Check if configuration is valid
     */
    isValid(): boolean;
    /**
     * Get service capabilities
     */
    getCapabilities(): ServiceCapabilities;
    /**
     * Check if a specific capability is available
     */
    hasCapability(capability: keyof ServiceCapabilities): boolean;
    /**
     * Get configuration for specific services
     */
    getJinaConfig(): {
        apiKey: string;
        isAvailable: boolean;
    };
    getTurbopufferConfig(): {
        apiKey: string;
        isAvailable: boolean;
    };
    getSearchConfig(): SearchConfig;
    getChunkingConfig(): ChunkingConfig;
    getProcessingConfig(): ProcessingConfig;
    /**
     * Log configuration status to console
     */
    logConfigurationStatus(): void;
    /**
     * Get configuration summary for status reporting
     */
    getConfigurationSummary(): {
        isValid: boolean;
        capabilities: ServiceCapabilities;
        keyStatus: {
            jina: 'configured' | 'test' | 'missing';
            turbopuffer: 'configured' | 'test' | 'missing';
        };
        errors: string[];
        warnings: string[];
    };
    /**
     * Create a masked version of the config for logging (hides API keys)
     */
    getMaskedConfig(): Record<string, any>;
    /**
     * Mask API key for safe logging
     */
    private maskApiKey;
    /**
     * Reset configuration to defaults
     */
    resetToDefaults(): void;
    /**
     * Check if configuration has changed since last validation
     */
    needsRevalidation(): boolean;
    /**
     * Force revalidation of configuration
     */
    revalidate(allowTestKeys?: boolean): ConfigValidationResult;
}
//# sourceMappingURL=ConfigurationService.d.ts.map