import { Node } from 'estree';
import { CodeMetrics, CodePattern } from './index';
export interface EnhancedAnalysisResult {
    summary: string;
    insights: string[];
    suggestions: string[];
    metrics: CodeMetrics;
    patterns: CodePattern[];
    astAnalysis: ASTAnalysisResult;
    codeSmells: CodeSmell[];
    securityIssues: SecurityIssue[];
    performanceIssues: PerformanceIssue[];
    architecturePatterns: ArchitecturePattern[];
    dependencies: DependencyAnalysis;
    contextualData: ContextualAnalysis;
    healthScore: CodeHealthScore;
}
export interface ASTAnalysisResult {
    files: FileAnalysis[];
    globalScope: ScopeAnalysis;
    moduleGraph: ModuleGraph;
    exportMap: ExportMap;
    importMap: ImportMap;
    typeDefinitions: TypeDefinition[];
    functionSignatures: FunctionSignature[];
    classDefinitions: ClassDefinition[];
    interfaceDefinitions: InterfaceDefinition[];
}
export interface FileAnalysis {
    path: string;
    language: 'typescript' | 'javascript' | 'tsx' | 'jsx';
    size: number;
    lines: number;
    ast: Node;
    scope: ScopeAnalysis;
    exports: ExportInfo[];
    imports: ImportInfo[];
    functions: FunctionAnalysis[];
    classes: ClassAnalysis[];
    interfaces: InterfaceAnalysis[];
    variables: VariableAnalysis[];
    complexity: ComplexityMetrics;
    dependencies: string[];
    errors: ParseError[];
}
export interface ScopeAnalysis {
    type: 'global' | 'module' | 'function' | 'block' | 'class';
    variables: VariableInfo[];
    functions: FunctionInfo[];
    classes: ClassInfo[];
    nested: ScopeAnalysis[];
    references: Reference[];
}
export interface VariableInfo {
    name: string;
    type: string | null;
    kind: 'var' | 'let' | 'const';
    location: CodeLocation;
    references: Reference[];
    mutated: boolean;
    exported: boolean;
    scope: string;
}
export interface FunctionInfo {
    name: string;
    type: 'function' | 'arrow' | 'method' | 'constructor';
    parameters: Parameter[];
    returnType: string | null;
    location: CodeLocation;
    complexity: ComplexityMetrics;
    references: Reference[];
    exported: boolean;
    async: boolean;
    generator: boolean;
}
export interface ClassInfo {
    name: string;
    extends: string | null;
    implements: string[];
    properties: PropertyInfo[];
    methods: MethodInfo[];
    constructor: ConstructorInfo | null;
    location: CodeLocation;
    exported: boolean;
    abstract: boolean;
}
export interface ModuleGraph {
    nodes: ModuleNode[];
    edges: ModuleEdge[];
    cycles: string[][];
    entryPoints: string[];
    orphans: string[];
}
export interface ModuleNode {
    path: string;
    type: 'entry' | 'internal' | 'external' | 'test';
    exports: ExportInfo[];
    imports: ImportInfo[];
    size: number;
    dependencies: string[];
    dependents: string[];
}
export interface ModuleEdge {
    from: string;
    to: string;
    type: 'import' | 'require' | 'dynamic';
    specifiers: string[];
}
export interface ExportInfo {
    name: string;
    type: 'default' | 'named' | 'namespace';
    kind: 'function' | 'class' | 'variable' | 'type' | 'interface';
    location: CodeLocation;
    source: string | null;
}
export interface ImportInfo {
    source: string;
    specifiers: ImportSpecifier[];
    type: 'import' | 'require' | 'dynamic';
    location: CodeLocation;
    resolved: string | null;
}
export interface ImportSpecifier {
    name: string;
    alias: string | null;
    type: 'default' | 'named' | 'namespace';
}
export interface ComplexityMetrics {
    cyclomatic: number;
    cognitive: number;
    halstead: HalsteadMetrics;
    maintainabilityIndex: number;
    linesOfCode: number;
    logicalLinesOfCode: number;
    nestingDepth: number;
    parameters: number;
}
export interface HalsteadMetrics {
    operators: number;
    operands: number;
    distinctOperators: number;
    distinctOperands: number;
    length: number;
    vocabulary: number;
    volume: number;
    difficulty: number;
    effort: number;
    time: number;
    bugs: number;
}
export interface CodeSmell {
    type: CodeSmellType;
    severity: 'low' | 'medium' | 'high' | 'critical';
    message: string;
    location: CodeLocation;
    suggestion: string;
    confidence: number;
    category: 'maintainability' | 'readability' | 'performance' | 'security';
}
export type CodeSmellType = 'long-method' | 'large-class' | 'long-parameter-list' | 'duplicate-code' | 'dead-code' | 'complex-conditional' | 'magic-number' | 'deep-nesting' | 'tight-coupling' | 'shotgun-surgery' | 'feature-envy' | 'data-clumps' | 'primitive-obsession' | 'switch-statements' | 'refused-bequest' | 'lazy-class' | 'speculative-generality';
export interface SecurityIssue {
    type: SecurityIssueType;
    severity: 'info' | 'low' | 'medium' | 'high' | 'critical';
    message: string;
    location: CodeLocation;
    cwe: string | null;
    suggestion: string;
    confidence: number;
}
export type SecurityIssueType = 'sql-injection' | 'xss' | 'path-traversal' | 'command-injection' | 'insecure-random' | 'hardcoded-secret' | 'weak-crypto' | 'insecure-transport' | 'unsafe-eval' | 'prototype-pollution' | 'regex-dos' | 'information-disclosure';
export interface PerformanceIssue {
    type: PerformanceIssueType;
    severity: 'low' | 'medium' | 'high';
    message: string;
    location: CodeLocation;
    impact: 'memory' | 'cpu' | 'network' | 'storage';
    suggestion: string;
    confidence: number;
}
export type PerformanceIssueType = 'inefficient-loop' | 'memory-leak' | 'blocking-operation' | 'large-object' | 'frequent-allocation' | 'inefficient-regex' | 'synchronous-io' | 'missing-cache' | 'redundant-computation' | 'inefficient-data-structure';
export interface ArchitecturePattern {
    type: ArchitecturePatternType;
    name: string;
    description: string;
    confidence: number;
    components: string[];
    relationships: PatternRelationship[];
    adherence: number;
    violations: PatternViolation[];
}
export type ArchitecturePatternType = 'mvc' | 'mvp' | 'mvvm' | 'repository' | 'factory' | 'singleton' | 'observer' | 'strategy' | 'decorator' | 'facade' | 'adapter' | 'command' | 'state' | 'template-method' | 'builder' | 'proxy' | 'chain-of-responsibility' | 'mediator' | 'visitor' | 'composite' | 'bridge' | 'flyweight' | 'prototype' | 'abstract-factory';
export interface PatternRelationship {
    from: string;
    to: string;
    type: 'extends' | 'implements' | 'uses' | 'contains' | 'depends-on';
}
export interface PatternViolation {
    rule: string;
    severity: 'low' | 'medium' | 'high';
    location: CodeLocation;
    message: string;
}
export interface DependencyAnalysis {
    external: ExternalDependency[];
    internal: InternalDependency[];
    graph: DependencyGraph;
    metrics: DependencyMetrics;
    issues: DependencyIssue[];
    suggestions: DependencySuggestion[];
}
export interface ExternalDependency {
    name: string;
    version: string;
    type: 'production' | 'development' | 'peer' | 'optional';
    size: number;
    license: string;
    vulnerabilities: Vulnerability[];
    outdated: boolean;
    usage: DependencyUsage[];
}
export interface InternalDependency {
    path: string;
    type: 'module' | 'component' | 'utility' | 'type';
    dependents: string[];
    dependencies: string[];
    coupling: number;
    cohesion: number;
}
export interface DependencyGraph {
    nodes: DependencyNode[];
    edges: DependencyEdge[];
    cycles: string[][];
    depth: number;
    fanIn: Record<string, number>;
    fanOut: Record<string, number>;
}
export interface DependencyNode {
    id: string;
    type: 'internal' | 'external' | 'builtin';
    layer: number;
    critical: boolean;
}
export interface DependencyEdge {
    from: string;
    to: string;
    weight: number;
    type: 'static' | 'dynamic';
}
export interface DependencyMetrics {
    totalDependencies: number;
    directDependencies: number;
    transitiveDependencies: number;
    cyclomaticComplexity: number;
    instability: number;
    abstractness: number;
    distance: number;
}
export interface DependencyIssue {
    type: 'circular' | 'unused' | 'outdated' | 'vulnerable' | 'license';
    severity: 'low' | 'medium' | 'high' | 'critical';
    message: string;
    affected: string[];
}
export interface DependencySuggestion {
    type: 'remove' | 'update' | 'replace' | 'consolidate';
    target: string;
    reason: string;
    impact: 'positive' | 'neutral' | 'negative';
}
export interface ContextualAnalysis {
    namingConventions: NamingConvention[];
    codingStyle: CodingStyle;
    patterns: UsagePattern[];
    conventions: Convention[];
    preferences: Preference[];
    evolution: EvolutionMetrics;
}
export interface NamingConvention {
    type: 'function' | 'variable' | 'class' | 'interface' | 'type' | 'constant';
    pattern: string;
    examples: string[];
    adherence: number;
    violations: string[];
}
export interface CodingStyle {
    indentation: 'tabs' | 'spaces';
    indentSize: number;
    semicolons: boolean;
    quotes: 'single' | 'double' | 'backtick';
    trailingCommas: boolean;
    bracketSpacing: boolean;
    lineLength: number;
    consistency: number;
}
export interface UsagePattern {
    type: 'import' | 'export' | 'function' | 'class' | 'hook' | 'component';
    pattern: string;
    frequency: number;
    examples: string[];
    recommendation: string;
}
export interface Convention {
    name: string;
    description: string;
    adherence: number;
    violations: ConventionViolation[];
}
export interface ConventionViolation {
    location: CodeLocation;
    message: string;
    suggestion: string;
}
export interface Preference {
    category: 'language' | 'framework' | 'library' | 'pattern' | 'style';
    preference: string;
    confidence: number;
    evidence: string[];
}
export interface EvolutionMetrics {
    linesAdded: number;
    linesRemoved: number;
    filesModified: number;
    complexity: number;
    stability: number;
    velocity: number;
    churn: number;
}
export interface CodeHealthScore {
    overall: number;
    categories: {
        maintainability: number;
        reliability: number;
        security: number;
        performance: number;
        testability: number;
        readability: number;
    };
    trends: {
        improving: string[];
        declining: string[];
        stable: string[];
    };
    recommendations: HealthRecommendation[];
}
export interface HealthRecommendation {
    category: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    action: string;
    impact: string;
    effort: 'small' | 'medium' | 'large';
}
export interface AnalysisCache {
    timestamp: number;
    version: string;
    files: Map<string, FileAnalysisCache>;
    global: GlobalAnalysisCache;
    invalidated: Set<string>;
}
export interface FileAnalysisCache {
    hash: string;
    modifiedTime: number;
    analysis: FileAnalysis;
    dependencies: string[];
}
export interface GlobalAnalysisCache {
    moduleGraph: ModuleGraph;
    dependencyAnalysis: DependencyAnalysis;
    architecturePatterns: ArchitecturePattern[];
    contextualData: ContextualAnalysis;
}
export interface CodeLocation {
    file: string;
    start: Position;
    end: Position;
}
export interface Position {
    line: number;
    column: number;
}
export interface Reference {
    location: CodeLocation;
    type: 'read' | 'write' | 'call';
    context: string;
}
export interface Parameter {
    name: string;
    type: string | null;
    optional: boolean;
    defaultValue: string | null;
}
export interface PropertyInfo {
    name: string;
    type: string | null;
    visibility: 'public' | 'private' | 'protected';
    static: boolean;
    readonly: boolean;
    optional: boolean;
}
export interface MethodInfo extends FunctionInfo {
    visibility: 'public' | 'private' | 'protected';
    static: boolean;
    abstract: boolean;
    override: boolean;
}
export interface ConstructorInfo {
    parameters: Parameter[];
    location: CodeLocation;
    visibility: 'public' | 'private' | 'protected';
}
export interface TypeDefinition {
    name: string;
    type: 'type' | 'interface' | 'enum' | 'class';
    definition: string;
    location: CodeLocation;
    exported: boolean;
    generic: boolean;
    parameters: string[];
}
export interface FunctionSignature {
    name: string;
    parameters: Parameter[];
    returnType: string | null;
    generic: boolean;
    overloads: FunctionSignature[];
}
export interface ClassDefinition {
    name: string;
    extends: string | null;
    implements: string[];
    abstract: boolean;
    generic: boolean;
    location: CodeLocation;
}
export interface InterfaceDefinition {
    name: string;
    extends: string[];
    properties: PropertySignature[];
    methods: MethodSignature[];
    generic: boolean;
    location: CodeLocation;
}
export interface PropertySignature {
    name: string;
    type: string;
    optional: boolean;
    readonly: boolean;
}
export interface MethodSignature {
    name: string;
    parameters: Parameter[];
    returnType: string;
    optional: boolean;
}
export interface FunctionAnalysis extends FunctionInfo {
    body: Node;
    variables: VariableInfo[];
    calls: FunctionCall[];
    returns: ReturnStatement[];
    throws: ThrowStatement[];
}
export interface ClassAnalysis extends ClassInfo {
    body: Node;
    dependencies: string[];
    cohesion: number;
    coupling: number;
}
export interface InterfaceAnalysis {
    name: string;
    properties: PropertySignature[];
    methods: MethodSignature[];
    extends: string[];
    location: CodeLocation;
    usage: Reference[];
}
export interface VariableAnalysis extends VariableInfo {
    initializer: Node | null;
    usages: Reference[];
    lifecycle: 'short' | 'medium' | 'long';
}
export interface FunctionCall {
    name: string;
    location: CodeLocation;
    arguments: number;
    context: string;
}
export interface ReturnStatement {
    location: CodeLocation;
    type: string | null;
    value: Node | null;
}
export interface ThrowStatement {
    location: CodeLocation;
    error: string;
    context: string;
}
export interface ParseError {
    message: string;
    location: CodeLocation;
    severity: 'error' | 'warning';
}
export interface DependencyUsage {
    location: CodeLocation;
    type: 'import' | 'require' | 'call';
    specifier: string;
}
export interface Vulnerability {
    id: string;
    severity: 'low' | 'moderate' | 'high' | 'critical';
    title: string;
    description: string;
    cwe: string[];
    cvss: number;
}
export interface ExportMap {
    [module: string]: ExportInfo[];
}
export interface ImportMap {
    [module: string]: ImportInfo[];
}
export interface EnhancedAnalysisOptions {
    depth: number;
    includeTests: boolean;
    excludePatterns: string[];
    parseOptions: {
        typescript: boolean;
        jsx: boolean;
        decorators: boolean;
        strictMode: boolean;
    };
    analysis: {
        ast: boolean;
        complexity: boolean;
        security: boolean;
        performance: boolean;
        patterns: boolean;
        dependencies: boolean;
        contextual: boolean;
    };
    caching: {
        enabled: boolean;
        strategy: 'aggressive' | 'conservative' | 'manual';
        ttl: number;
    };
    performance: {
        maxFileSize: number;
        maxComplexity: number;
        timeout: number;
        parallel: boolean;
    };
}
export interface SemanticAnalysisResult {
    summary: SemanticSummary;
    patterns: SemanticPattern[];
    namingConsistency: NamingConsistencyAnalysis;
    architecturalConsistency: ArchitecturalConsistencyAnalysis;
    crossFileAnalysis: CrossFileAnalysis;
    qualityMetrics: SemanticQualityMetrics;
    recommendations: SemanticRecommendation[];
    refactoringOpportunities: RefactoringOpportunity[];
}
export interface SemanticSummary {
    overallConsistencyScore: number;
    totalPatterns: number;
    inconsistencies: number;
    criticalIssues: number;
    refactoringOpportunities: number;
    codebaseMaturity: 'early' | 'developing' | 'mature' | 'legacy';
    dominantPatterns: string[];
    architecturalStyle: string[];
}
export interface SemanticPattern {
    id: string;
    name: string;
    type: SemanticPatternType;
    description: string;
    frequency: number;
    confidence: number;
    locations: PatternLocation[];
    variations: PatternVariation[];
    relatedPatterns: string[];
    quality: PatternQuality;
}
export type SemanticPatternType = 'naming-convention' | 'architectural-pattern' | 'code-organization' | 'interface-design' | 'error-handling' | 'data-flow' | 'dependency-injection' | 'configuration-management' | 'testing-strategy' | 'logging-strategy' | 'security-pattern' | 'performance-pattern' | 'design-pattern' | 'anti-pattern';
export interface PatternLocation {
    filePath: string;
    symbolPath?: string;
    startLine: number;
    endLine: number;
    context: string;
    codeSnippet: string;
    role: 'definition' | 'usage' | 'implementation' | 'variation';
}
export interface PatternVariation {
    description: string;
    examples: PatternLocation[];
    reasonForVariation: string;
    impactOnConsistency: 'none' | 'low' | 'medium' | 'high';
    suggestedStandardization?: string;
}
export interface PatternQuality {
    consistency: number;
    clarity: number;
    maintainability: number;
    testability: number;
    performance: number;
    security: number;
    reusability: number;
    overall: number;
}
export interface NamingConsistencyAnalysis {
    overallScore: number;
    conventions: SemanticNamingConvention[];
    violations: NamingViolation[];
    suggestions: NamingSuggestion[];
    patterns: NamingPattern[];
    inconsistencies: NamingInconsistency[];
}
export interface SemanticNamingConvention {
    type: NamingConventionType;
    pattern: string;
    regex: string;
    adherence: number;
    examples: string[];
    violations: number;
    dominantCase: 'camelCase' | 'PascalCase' | 'snake_case' | 'SCREAMING_SNAKE_CASE' | 'kebab-case';
}
export type NamingConventionType = 'variable' | 'function' | 'class' | 'interface' | 'type' | 'enum' | 'constant' | 'property' | 'method' | 'parameter' | 'file' | 'directory' | 'namespace' | 'module';
export interface NamingViolation {
    type: NamingConventionType;
    name: string;
    location: CodeLocation;
    expectedPattern: string;
    suggestedName: string;
    severity: 'low' | 'medium' | 'high';
    impact: string[];
    relatedViolations: CodeLocation[];
}
export interface NamingSuggestion {
    id?: string;
    type: 'standardization' | 'clarification' | 'convention-adoption';
    description: string;
    examples: NamingExample[];
    impact: 'low' | 'medium' | 'high';
    effort: 'low' | 'medium' | 'high';
    benefits: string[];
    priority?: number;
}
export interface NamingExample {
    current: string;
    suggested: string;
    context: string;
    reasoning: string;
}
export interface NamingPattern {
    pattern: string;
    description: string;
    frequency: number;
    consistency: number;
    examples: string[];
    relatedPatterns: string[];
}
export interface NamingInconsistency {
    description: string;
    examples: NamingExample[];
    severity: 'low' | 'medium' | 'high';
    scope: 'file' | 'module' | 'project';
    suggestedResolution: string;
}
export interface ArchitecturalConsistencyAnalysis {
    overallScore: number;
    patterns: ArchitecturePattern[];
    violations: ArchitecturalViolation[];
    layering: LayeringAnalysis;
    modularity: ModularityAnalysis;
    coupling: CouplingAnalysis;
    cohesion: CohesionAnalysis;
    principles: ArchitecturalPrincipleAdherence[];
}
export interface ArchitecturalViolation {
    type: ArchitecturalViolationType;
    description: string;
    location: CodeLocation;
    severity: 'low' | 'medium' | 'high' | 'critical';
    impact: string[];
    suggestedFix: string;
    relatedViolations: CodeLocation[];
}
export type ArchitecturalViolationType = 'layer-violation' | 'circular-dependency' | 'tight-coupling' | 'low-cohesion' | 'separation-of-concerns' | 'single-responsibility' | 'dependency-inversion' | 'interface-segregation' | 'open-closed' | 'liskov-substitution';
export interface LayeringAnalysis {
    layers: Layer[];
    violations: LayerViolation[];
    consistency: number;
    clarity: number;
}
export interface Layer {
    name: string;
    level: number;
    components: string[];
    dependencies: string[];
    allowedDependencies: string[];
    violations: number;
}
export interface LayerViolation {
    from: string;
    to: string;
    violationType: 'upward-dependency' | 'skip-layer' | 'circular-reference';
    severity: 'low' | 'medium' | 'high';
}
export interface ModularityAnalysis {
    moduleCount: number;
    averageModuleSize: number;
    moduleCoherence: number;
    interfaceComplexity: number;
    encapsulation: number;
    modules: ModuleAnalysis[];
}
export interface ModuleAnalysis {
    name: string;
    path: string;
    size: number;
    complexity: number;
    cohesion: number;
    coupling: number;
    interfaces: string[];
    dependencies: string[];
    responsibilities: string[];
}
export interface CouplingAnalysis {
    overall: number;
    afferent: number;
    efferent: number;
    instability: number;
    pairs: CouplingPair[];
    hotspots: string[];
}
export interface CouplingPair {
    from: string;
    to: string;
    strength: number;
    type: 'data' | 'control' | 'stamp' | 'common' | 'content';
}
export interface CohesionAnalysis {
    overall: number;
    modules: ModuleCohesion[];
    lowCohesionModules: string[];
}
export interface ModuleCohesion {
    name: string;
    score: number;
    type: 'functional' | 'sequential' | 'communicational' | 'procedural' | 'temporal' | 'logical' | 'coincidental';
    issues: string[];
}
export interface ArchitecturalPrincipleAdherence {
    principle: ArchitecturalPrinciple;
    adherence: number;
    violations: ArchitecturalViolation[];
    examples: PrincipleExample[];
}
export type ArchitecturalPrinciple = 'single-responsibility' | 'open-closed' | 'liskov-substitution' | 'interface-segregation' | 'dependency-inversion' | 'separation-of-concerns' | 'dry' | 'kiss' | 'yagni' | 'composition-over-inheritance';
export interface PrincipleExample {
    description: string;
    location: CodeLocation;
    codeSnippet: string;
    explanation: string;
}
export interface CrossFileAnalysis {
    dependencies: CrossFileDependency[];
    sharedPatterns: SharedPattern[];
    inconsistencies: CrossFileInconsistency[];
    refactoringOpportunities: CrossFileRefactoringOpportunity[];
    duplications: CodeDuplication[];
}
export interface CrossFileDependency {
    from: string;
    to: string;
    type: 'import' | 'inheritance' | 'composition' | 'usage';
    strength: number;
    bidirectional: boolean;
    issues: string[];
}
export interface SharedPattern {
    pattern: string;
    files: string[];
    variations: PatternVariation[];
    consistency: number;
    suggestedStandardization?: string;
}
export interface CrossFileInconsistency {
    type: 'naming' | 'structure' | 'pattern' | 'style';
    description: string;
    files: string[];
    examples: InconsistencyExample[];
    severity: 'low' | 'medium' | 'high';
    suggestedResolution: string;
}
export interface InconsistencyExample {
    file: string;
    location: CodeLocation;
    code: string;
    issue: string;
}
export interface CrossFileRefactoringOpportunity {
    type: 'extract-common' | 'merge-similar' | 'standardize-pattern' | 'reduce-duplication';
    description: string;
    files: string[];
    benefit: 'maintainability' | 'readability' | 'performance' | 'consistency';
    effort: 'low' | 'medium' | 'high';
    impact: 'low' | 'medium' | 'high';
    suggestedApproach: string;
}
export interface CodeDuplication {
    type: 'exact' | 'similar' | 'structural';
    files: string[];
    locations: CodeLocation[];
    similarity: number;
    size: number;
    suggestedExtraction: string;
}
export interface SemanticQualityMetrics {
    consistency: ConsistencyMetrics;
    clarity: ClarityMetrics;
    maintainability: MaintainabilityMetrics;
    reusability: ReusabilityMetrics;
    testability: TestabilityMetrics;
    overall: number;
}
export interface ConsistencyMetrics {
    naming: number;
    patterns: number;
    architecture: number;
    style: number;
    overall: number;
}
export interface ClarityMetrics {
    symbolNames: number;
    codeStructure: number;
    interfaces: number;
    documentation: number;
    overall: number;
}
export interface MaintainabilityMetrics {
    modularity: number;
    coupling: number;
    cohesion: number;
    complexity: number;
    overall: number;
}
export interface ReusabilityMetrics {
    abstraction: number;
    generalization: number;
    modularity: number;
    interfaces: number;
    overall: number;
}
export interface TestabilityMetrics {
    isolation: number;
    dependencies: number;
    complexity: number;
    interfaces: number;
    overall: number;
}
export interface SemanticRecommendation {
    id: string;
    type: SemanticRecommendationType;
    priority: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    rationale: string;
    impact: RecommendationImpact;
    effort: 'low' | 'medium' | 'high';
    implementation: ImplementationGuidance;
    alternatives: Alternative[];
    dependencies: string[];
    risks: string[];
}
export type SemanticRecommendationType = 'naming-standardization' | 'pattern-consolidation' | 'architectural-improvement' | 'code-organization' | 'interface-redesign' | 'dependency-optimization' | 'duplication-elimination' | 'consistency-improvement' | 'maintainability-enhancement' | 'performance-optimization';
export interface RecommendationImpact {
    consistency: 'none' | 'low' | 'medium' | 'high';
    maintainability: 'none' | 'low' | 'medium' | 'high';
    readability: 'none' | 'low' | 'medium' | 'high';
    performance: 'none' | 'low' | 'medium' | 'high';
    testability: 'none' | 'low' | 'medium' | 'high';
    security: 'none' | 'low' | 'medium' | 'high';
}
export interface ImplementationGuidance {
    steps: ImplementationStep[];
    tools: string[];
    estimatedTime: string;
    prerequisites: string[];
    validationCriteria: string[];
}
export interface ImplementationStep {
    order: number;
    description: string;
    details: string;
    files: string[];
    automation: AutomationInfo | null;
}
export interface AutomationInfo {
    tool: 'serena' | 'ast-modification' | 'regex-replace' | 'manual';
    script?: string;
    parameters?: Record<string, any>;
    validation?: string;
}
export interface Alternative {
    title: string;
    description: string;
    pros: string[];
    cons: string[];
    effort: 'low' | 'medium' | 'high';
    impact: RecommendationImpact;
}
export interface RefactoringOpportunity {
    id: string;
    type: RefactoringType;
    title: string;
    description: string;
    scope: RefactoringScope;
    benefit: RefactoringBenefit;
    complexity: 'low' | 'medium' | 'high';
    risk: 'low' | 'medium' | 'high';
    locations: CodeLocation[];
    automatable: boolean;
    prerequisites: string[];
    validationStrategy: string;
}
export type RefactoringType = 'extract-method' | 'extract-class' | 'extract-interface' | 'extract-constant' | 'extract-variable' | 'inline-method' | 'inline-variable' | 'rename-symbol' | 'move-method' | 'move-class' | 'consolidate-pattern' | 'standardize-naming' | 'restructure-hierarchy' | 'simplify-conditional' | 'eliminate-duplication';
export interface RefactoringScope {
    type: 'symbol' | 'file' | 'module' | 'project';
    files: string[];
    symbols: string[];
    estimatedChanges: number;
}
export interface RefactoringBenefit {
    consistency: number;
    maintainability: number;
    readability: number;
    performance: number;
    testability: number;
    overall: number;
}
export interface SemanticAnalysisConfig {
    patterns: {
        detectNamingPatterns: boolean;
        detectArchitecturalPatterns: boolean;
        detectAntiPatterns: boolean;
        customPatterns: CustomPattern[];
    };
    consistency: {
        namingConventions: NamingConventionConfig[];
        architecturalRules: ArchitecturalRule[];
        styleRules: StyleRule[];
    };
    analysis: {
        crossFileAnalysis: boolean;
        deepSymbolAnalysis: boolean;
        performanceImpactAnalysis: boolean;
        securityPatternAnalysis: boolean;
    };
    refactoring: {
        suggestRefactoring: boolean;
        automationLevel: 'conservative' | 'moderate' | 'aggressive';
        riskTolerance: 'low' | 'medium' | 'high';
    };
    output: {
        includeCodeSnippets: boolean;
        maxRecommendations: number;
        prioritizeByImpact: boolean;
        includeImplementationGuides: boolean;
    };
}
export interface CustomPattern {
    name: string;
    description: string;
    regex?: string;
    astQuery?: string;
    semanticQuery?: string;
    category: SemanticPatternType;
}
export interface NamingConventionConfig {
    type: NamingConventionType;
    pattern: string;
    required: boolean;
    exceptions: string[];
    scope: 'file' | 'module' | 'project';
}
export interface ArchitecturalRule {
    name: string;
    description: string;
    pattern: string;
    enforcement: 'warning' | 'error';
    scope: string[];
}
export interface StyleRule {
    name: string;
    pattern: string;
    preference: string;
    scope: 'file' | 'module' | 'project';
}
//# sourceMappingURL=analysis.d.ts.map