/**
 * RAG-Enhanced Codebase Analysis Tool
 *
 * Provides comprehensive codebase analysis using Retrieval-Augmented Generation.
 * Executes parallel semantic queries to understand architecture, patterns,
 * dependencies, tests, and security measures.
 *
 * @module @wundr/mcp-server/tools/codebase-analysis-rag
 */
import { z } from 'zod';
import type { McpToolResult } from './registry.js';
/**
 * Input schema for codebase analysis with RAG
 */
export declare const CodebaseAnalysisRagInputSchema: z.ZodObject<{
    targetPath: z.ZodString;
    storeName: z.ZodOptional<z.ZodString>;
    forceReindex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
    includePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    excludePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    analysisCategories: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["architecture", "patterns", "dependencies", "tests", "security"]>, "many">>>;
    maxResultsPerCategory: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    generateSummary: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    includePatterns: string[];
    excludePatterns: string[];
    targetPath: string;
    forceReindex: boolean;
    analysisCategories: ("security" | "architecture" | "patterns" | "dependencies" | "tests")[];
    maxResultsPerCategory: number;
    generateSummary: boolean;
    storeName?: string | undefined;
}, {
    targetPath: string;
    includePatterns?: string[] | undefined;
    excludePatterns?: string[] | undefined;
    storeName?: string | undefined;
    forceReindex?: boolean | undefined;
    analysisCategories?: ("security" | "architecture" | "patterns" | "dependencies" | "tests")[] | undefined;
    maxResultsPerCategory?: number | undefined;
    generateSummary?: boolean | undefined;
}>;
export type CodebaseAnalysisRagInput = z.infer<typeof CodebaseAnalysisRagInputSchema>;
/**
 * Analysis result for a single category
 */
export interface CategoryAnalysisResult {
    /** Category name */
    category: string;
    /** Semantic query used */
    query: string;
    /** Matched files with relevance scores */
    matches: Array<{
        filePath: string;
        score: number;
        snippet?: string;
        metadata?: Record<string, unknown>;
    }>;
    /** Key findings for this category */
    findings: string[];
    /** Confidence score for the analysis (0-1) */
    confidence: number;
}
/**
 * Consolidated codebase analysis report
 */
export interface CodebaseAnalysisReport {
    /** Target path analyzed */
    targetPath: string;
    /** RAG store used */
    storeId: string;
    /** Timestamp of analysis */
    analyzedAt: string;
    /** Per-category analysis results */
    categories: CategoryAnalysisResult[];
    /** Overall codebase summary */
    summary: {
        /** Primary programming languages detected */
        languages: string[];
        /** Estimated project type (monorepo, library, application, etc.) */
        projectType: string;
        /** Key architectural patterns identified */
        architecturePatterns: string[];
        /** Code quality indicators */
        qualityIndicators: {
            hasTests: boolean;
            hasDocumentation: boolean;
            hasTypeDefinitions: boolean;
            hasSecurityMeasures: boolean;
        };
        /** Total files analyzed */
        totalFilesAnalyzed: number;
        /** Total chunks indexed */
        totalChunksIndexed: number;
    };
    /** Recommendations based on analysis */
    recommendations: string[];
    /** Warnings or concerns identified */
    warnings: string[];
    /** Analysis metadata */
    metadata: {
        analysisTimeMs: number;
        indexingTimeMs?: number;
        wasReindexed: boolean;
    };
}
/**
 * Output from codebase analysis
 */
export interface CodebaseAnalysisRagOutput {
    report: CodebaseAnalysisReport;
}
/**
 * Analyze a codebase using RAG-enhanced semantic search
 *
 * @param input - Analysis input parameters
 * @returns Comprehensive codebase analysis report
 */
export declare function analyzeCodebaseWithRag(input: CodebaseAnalysisRagInput): Promise<McpToolResult<CodebaseAnalysisRagOutput>>;
/**
 * Tool definition for MCP registration
 */
export declare const codebaseAnalysisRagTool: {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            targetPath: {
                type: string;
                description: string;
            };
            storeName: {
                type: string;
                description: string;
            };
            forceReindex: {
                type: string;
                description: string;
                default: boolean;
            };
            includePatterns: {
                type: string;
                items: {
                    type: string;
                };
                description: string;
                default: string[];
            };
            excludePatterns: {
                type: string;
                items: {
                    type: string;
                };
                description: string;
                default: string[];
            };
            analysisCategories: {
                type: string;
                items: {
                    type: string;
                    enum: string[];
                };
                description: string;
                default: string[];
            };
            maxResultsPerCategory: {
                type: string;
                description: string;
                default: number;
            };
            generateSummary: {
                type: string;
                description: string;
                default: boolean;
            };
        };
        required: string[];
    };
    category: string;
};
//# sourceMappingURL=codebase-analysis-rag.d.ts.map