@aaswe/codebase-ai/dist/services/layer1/rdf-generator/ConcreteInformationExtractor.d.ts

AI-Assisted Software Engineering (AASWE) - Rich codebase context for IDE LLMs

/**
 * Concrete Information Extractor
 *
 * Extracts concrete, actual information from code analysis results
 * to generate TTL files with real class names, method signatures,
 * dependencies, and business context indicators.
 */
import { AnalysisResult } from '../ast-analyzer/types';
export interface ConcreteCodeStructure {
    actualClasses: ConcreteClass[];
    actualFunctions: ConcreteFunction[];
    actualDependencies: ConcreteDependency[];
    actualExports: ConcreteExport[];
    actualImports: ConcreteImport[];
    architecturalPatterns: ArchitecturalPattern[];
    businessDomainIndicators: BusinessDomainIndicator[];
    qualityMetrics: ConcreteQualityMetrics;
}
export interface ConcreteClass {
    name: string;
    fullyQualifiedName: string;
    methods: ConcreteMethod[];
    properties: ConcreteProperty[];
    inheritance: {
        extends?: string | undefined;
        implements: string[];
    };
    visibility: 'public' | 'private' | 'protected';
    isAbstract: boolean;
    sourceLocation: SourceLocation;
    businessPurpose?: string;
    designPatterns: string[];
}
export interface ConcreteMethod {
    name: string;
    signature: string;
    parameters: ConcreteParameter[];
    returnType: string;
    visibility: 'public' | 'private' | 'protected';
    isStatic: boolean;
    isAsync: boolean;
    complexity: number;
    sourceLocation: SourceLocation;
    businessPurpose?: string;
    sideEffects: string[];
}
export interface ConcreteFunction {
    name: string;
    signature: string;
    parameters: ConcreteParameter[];
    returnType: string;
    isAsync: boolean;
    isExported: boolean;
    complexity: number;
    sourceLocation: SourceLocation;
    businessPurpose?: string;
    dependencies: string[];
}
export interface ConcreteParameter {
    name: string;
    type: string;
    isOptional: boolean;
    defaultValue?: string;
    businessMeaning?: string;
}
export interface ConcreteProperty {
    name: string;
    type: string;
    visibility: 'public' | 'private' | 'protected';
    isStatic: boolean;
    isReadonly: boolean;
    defaultValue?: string | undefined;
    businessPurpose?: string;
}
export interface ConcreteDependency {
    name: string;
    version?: string;
    type: 'external' | 'internal' | 'builtin';
    usage: 'import' | 'require' | 'dynamic';
    usedSymbols: string[];
    businessJustification?: string;
}
export interface ConcreteExport {
    name: string;
    type: 'function' | 'class' | 'variable' | 'type' | 'interface';
    isDefault: boolean;
    businessValue?: string;
}
export interface ConcreteImport {
    source: string;
    imports: {
        name: string;
        alias?: string;
        isDefault: boolean;
        isNamespace: boolean;
    }[];
    businessReason?: string;
}
export interface ArchitecturalPattern {
    name: string;
    confidence: number;
    evidence: string[];
    businessBenefit?: string;
}
export interface BusinessDomainIndicator {
    domain: string;
    confidence: number;
    evidence: string[];
    keywords: string[];
}
export interface ConcreteQualityMetrics {
    complexity: {
        cyclomatic: number;
        cognitive: number;
        maintainability: number;
    };
    testability: {
        score: number;
        factors: string[];
    };
    reusability: {
        score: number;
        factors: string[];
    };
    documentation: {
        coverage: number;
        quality: number;
    };
}
export interface SourceLocation {
    file: string;
    startLine: number;
    endLine: number;
    startColumn: number;
    endColumn: number;
}
/**
 * Concrete Information Extractor
 *
 * Analyzes code structure to extract concrete, actionable information
 * for generating comprehensive TTL files with real implementation details.
 */
export declare class ConcreteInformationExtractor {
    /**
     * Extract concrete code structure from analysis result
     */
    extractConcreteStructure(analysisResult: AnalysisResult): ConcreteCodeStructure;
    /**
     * Extract concrete class information
     */
    private extractConcreteClasses;
    /**
     * Extract concrete method information from class
     */
    private extractConcreteMethods;
    /**
     * Extract concrete function information
     */
    private extractConcreteFunctions;
    /**
     * Extract concrete dependencies
     */
    private extractConcreteDependencies;
    /**
     * Extract concrete exports
     */
    private extractConcreteExports;
    /**
     * Extract concrete imports
     */
    private extractConcreteImports;
    /**
     * Detect architectural patterns
     */
    private detectArchitecturalPatterns;
    /**
     * Detect business domain indicators
     */
    private detectBusinessDomainIndicators;
    /**
     * Calculate concrete quality metrics
     */
    private calculateConcreteQualityMetrics;
    private buildFullyQualifiedName;
    private buildMethodSignature;
    private extractConcreteParameters;
    private extractConcreteProperties;
    private classifyDependencyType;
    private detectClassDesignPatterns;
    private analyzeSideEffects;
    private inferBusinessPurpose;
    private inferBusinessMeaning;
    private inferDependencyJustification;
    private inferBusinessValue;
    private inferImportReason;
    private calculateTestabilityScore;
    private getTestabilityFactors;
    private calculateReusabilityScore;
    private getReusabilityFactors;
    private calculateDocumentationCoverage;
    private calculateDocumentationQuality;
}
//# sourceMappingURL=ConcreteInformationExtractor.d.ts.map