/**
 * Advanced Package Management System
 * Handles extraction, creation, and management of Cortex packages
 */
import { ProjectAnalysis } from '../intelligence/project-analyzer';
import { DetectedPattern } from '../intelligence/pattern-matcher';
export interface PackageExtractionResult {
    packageName: string;
    description: string;
    files: ExtractedFile[];
    dependencies: string[];
    devDependencies: string[];
    peerDependencies: string[];
    exports: PackageExport[];
    metadata: PackageMetadata;
    validation: PackageValidationResult;
    publishable: boolean;
}
export interface ExtractedFile {
    originalPath: string;
    packagePath: string;
    content: string;
    type: FileType;
    imports: string[];
    exports: string[];
    transformations: Transformation[];
}
export interface PackageExport {
    name: string;
    path: string;
    type: 'component' | 'hook' | 'utility' | 'service' | 'type' | 'constant';
    documentation?: string;
}
export interface PackageMetadata {
    name: string;
    version: string;
    description: string;
    author: string;
    license: string;
    repository: string;
    keywords: string[];
    cortex: CortexMetadata;
}
export interface CortexMetadata {
    type: 'component-library' | 'utility-library' | 'service' | 'configuration' | 'pattern';
    category: string;
    patterns: string[];
    reusability: number;
    complexity: number;
    testCoverage: number;
    documentation: number;
    maintenance: MaintenanceInfo;
    usage: UsageInfo;
}
export interface ValidationError {
    type: 'no-files' | 'no-exports' | 'invalid-dependency' | 'missing-config' | 'syntax-error';
    message: string;
    severity: 'error';
    file?: string;
    line?: number;
}
export interface ValidationWarning {
    type: 'no-exports' | 'invalid-dependency' | 'missing-tests' | 'missing-docs';
    message: string;
    severity: 'warning';
    suggestion?: string;
    file?: string;
}
export interface PackageValidationResult {
    valid: boolean;
    errors: ValidationError[];
    warnings: ValidationWarning[];
    suggestions: string[];
}
export interface Transformation {
    type: 'import-path' | 'export-path' | 'namespace' | 'type-extraction' | 'dependency-injection';
    from: string;
    to: string;
    reason: string;
}
export interface MaintenanceInfo {
    lastUpdated: string;
    updateFrequency: string;
    breakingChanges: number;
    stability: 'experimental' | 'stable' | 'mature' | 'deprecated';
}
export interface UsageInfo {
    projects: string[];
    instances: number;
    patterns: string[];
    feedback: FeedbackItem[];
}
export interface FeedbackItem {
    project: string;
    rating: number;
    comment: string;
    date: string;
}
export type FileType = 'component' | 'hook' | 'utility' | 'service' | 'type' | 'test' | 'documentation' | 'configuration';
export interface PackageCreationOptions {
    name: string;
    namespace: string;
    description: string;
    type: CortexMetadata['type'];
    files: string[];
    projectPath: string;
    targetPath: string;
    includeTests: boolean;
    includeDocs: boolean;
    autoVersion: boolean;
    publish: boolean;
}
export interface PackageUpdateOptions {
    packageName: string;
    version: string;
    files?: string[];
    dependencies?: Record<string, string>;
    breaking: boolean;
    changelog: string;
    autoPublish: boolean;
}
export interface PackageRegistry {
    packages: RegisteredPackage[];
    dependencies: DependencyGraph;
    usage: UsageStatistics;
    quality: QualityMetrics;
}
export interface RegisteredPackage {
    name: string;
    version: string;
    metadata: PackageMetadata;
    published: boolean;
    downloads: number;
    rating: number;
    lastPublished: string;
}
export interface DependencyGraph {
    nodes: DependencyNode[];
    edges: DependencyEdge[];
    cycles: string[][];
    depth: number;
}
export interface DependencyNode {
    id: string;
    name: string;
    version: string;
    type: 'internal' | 'external';
}
export interface DependencyEdge {
    from: string;
    to: string;
    type: 'dependency' | 'devDependency' | 'peerDependency';
    version: string;
}
export interface UsageStatistics {
    totalDownloads: number;
    uniqueProjects: number;
    averageRating: number;
    topPackages: string[];
    trends: UsageTrend[];
}
export interface UsageTrend {
    packageName: string;
    period: string;
    downloads: number;
    growth: number;
}
export interface QualityMetrics {
    averageTestCoverage: number;
    averageDocumentation: number;
    averageComplexity: number;
    maintainabilityIndex: number;
    securityScore: number;
}
export declare class PackageManager {
    private registry;
    private config;
    constructor(config?: Partial<PackageManagerConfig>);
    /**
     * Extract a reusable package from a project
     */
    extractPackage(projectAnalysis: ProjectAnalysis, pattern: DetectedPattern, options: Partial<PackageCreationOptions>): Promise<PackageExtractionResult>;
    /**
     * Create a new Cortex package
     */
    createPackage(options: PackageCreationOptions): Promise<PackageExtractionResult>;
    /**
     * Update an existing package
     */
    updatePackage(options: PackageUpdateOptions): Promise<PackageExtractionResult>;
    /**
     * Analyze package quality
     */
    analyzePackageQuality(packagePath: string): Promise<QualityAnalysis>;
    /**
     * Find reusable components across projects
     */
    findReusableComponents(projects: ProjectAnalysis[], threshold?: number): Promise<ReusableComponent[]>;
    /**
     * Generate package from pattern
     */
    generatePackageFromPattern(pattern: DetectedPattern, targetPath: string): Promise<GeneratedPackage>;
    private generatePackageName;
    private extractFiles;
    private extractDependencies;
    private extractExports;
    private generateMetadata;
    private validatePackage;
    private writePackage;
    private publishPackage;
    private loadPackage;
    private generateIndexFile;
    private generateReadmeContent;
    private transformFile;
    private generatePackagePath;
    private detectFileType;
    private isExternalDependency;
    private extractDependencyName;
    private extractExportDocumentation;
    private mapPatternToPackageType;
    private isDependencyValid;
    private bumpMajorVersion;
    private bumpMinorVersion;
    private prepareFiles;
    private analyzeDependencies;
    private generateExports;
    private createMetadata;
    private updateFiles;
    private measureTestCoverage;
    private measureDocumentation;
    private measureComplexity;
    private measureMaintainability;
    private measureSecurity;
    private calculateQualityScore;
    private generateQualityRecommendations;
    private findProjectComponents;
    private generateComponentSignature;
    private assessComponentQuality;
    private findBestImplementation;
    private suggestPackageName;
    private estimateExtractionEffort;
    private createPackageStructure;
    private generatePackageJson;
    private generateReadme;
    private generateIndex;
    private generateTests;
    private generateDocumentation;
    private writeGeneratedPackage;
}
interface PackageManagerConfig {
    namespace: string;
    registryUrl: string;
    outputPath: string;
    autoVersion: boolean;
    autoPublish: boolean;
    qualityThreshold: number;
}
interface QualityAnalysis {
    score: number;
    testCoverage: number;
    documentation: number;
    complexity: number;
    maintainability: number;
    security: number;
    recommendations: string[];
}
interface ReusableComponent {
    signature: string;
    name: string;
    type: string;
    occurrences: ComponentOccurrence[];
    reusability: number;
    extractionCandidate: boolean;
    recommendedPackage: string;
    estimatedEffort: number;
}
interface ComponentOccurrence {
    project: string;
    component: any;
    quality: number;
}
interface GeneratedPackage {
    name: string;
    structure: any;
    files: Record<string, string>;
    metadata: any;
}
export default PackageManager;
//# sourceMappingURL=package-manager.d.ts.map