remcode/dist/search/query-processor.d.ts

Turn your AI assistant into a codebase expert. Intelligent code analysis, semantic search, and software engineering guidance through MCP integration.

/**
 * Represents the type of query to be performed
 */
export type QueryType = 'semantic' | 'exact' | 'pattern' | 'context';
/**
 * Represents the expected type of result
 */
export type ResultType = 'function' | 'class' | 'file' | 'pattern' | 'module' | 'any';
/**
 * Represents the possible query intents
 */
export type QueryIntent = 'find_implementation' | 'find_usage' | 'find_definition' | 'understand_code' | 'find_similar' | 'find_bugs' | 'find_complexity';
/**
 * Represents a processed search query with metadata
 */
export interface ProcessedQuery {
    originalQuery: string;
    processedQuery: string;
    queryType: QueryType;
    intent: QueryIntent;
    filters: QueryFilters;
    expectedResultType: ResultType;
    confidence: number;
}
/**
 * Filters that can be applied to search queries
 */
export interface QueryFilters {
    language?: string | string[];
    fileType?: string | string[];
    complexity?: 'low' | 'medium' | 'high' | 'any';
    path?: string;
    author?: string;
    dateRange?: {
        from?: Date;
        to?: Date;
    };
    minTokens?: number;
    maxTokens?: number;
    hasComments?: boolean;
    hasTests?: boolean;
    includePatterns?: string[];
    excludePatterns?: string[];
}
/**
 * Class for processing and optimizing code search queries
 */
export declare class QueryProcessor {
    private patternRules;
    /**
     * Process a raw search query into a structured form with metadata
     * @param query The raw search query
     * @returns Processed query with metadata
     */
    processQuery(query: string): Promise<ProcessedQuery>;
    /**
     * Normalize a query by trimming, converting to lowercase, and removing excess whitespace
     * @param query The raw query
     * @returns Normalized query
     */
    private normalizeQuery;
    /**
     * Determine the metadata for a query based on pattern matching
     * @param query The normalized query
     * @returns Query metadata including type, intent, and expected result type
     */
    private determineQueryMetadata;
    /**
     * Extract filters from a query string
     * @param query The normalized query
     * @returns Extracted filters
     */
    extractFilters(query: string): Promise<QueryFilters>;
    /**
     * Optimize a query based on its determined type
     * @param query The cleaned query
     * @param queryType The type of query
     * @returns Optimized query
     */
    optimizeQuery(query: string, queryType: QueryType): Promise<string>;
    /**
     * Optimize a query for semantic search
     * @param query The cleaned query
     * @returns Optimized semantic query
     */
    optimizeForSemanticSearch(query: string): Promise<string>;
    /**
     * Optimize a query for exact search
     * @param query The cleaned query
     * @returns Optimized exact query
     */
    private optimizeForExactSearch;
    /**
     * Optimize a query for pattern search
     * @param query The cleaned query
     * @returns Optimized pattern query
     */
    private optimizeForPatternSearch;
    /**
     * Optimize a query for context search
     * @param query The cleaned query
     * @returns Optimized context query
     */
    private optimizeForContextSearch;
    /**
     * Calculate a confidence score for the query interpretation
     * @param query The normalized query
     * @param queryType The determined query type
     * @param intent The determined intent
     * @returns Confidence score between 0 and 1
     */
    private calculateConfidence;
}