mcp-adr-analysis-server 1.1.0 → 2.0.2

package/dist/src/types/knowledge-generation.d.ts

@@ -0,0 +1,671 @@
+/**
+ * TypeScript interfaces for Knowledge Generation framework
+ * Implements advanced prompting techniques for domain-specific architectural knowledge
+ */
+import { z } from 'zod';
+export interface PromptObject {
+    prompt: string;
+    instructions: string;
+    context: any;
+}
+export type ArchitecturalDomain = 'web-applications' | 'mobile-applications' | 'microservices' | 'database-design' | 'cloud-infrastructure' | 'devops-cicd' | 'security-patterns' | 'performance-optimization' | 'api-design' | 'data-architecture';
+export type KnowledgeCategory = 'best-practices' | 'design-patterns' | 'anti-patterns' | 'technology-specific' | 'performance-considerations' | 'security-guidelines' | 'scalability-patterns' | 'testing-strategies';
+export type KnowledgeDepth = 'basic' | 'intermediate' | 'advanced';
+export type CacheStrategy = 'aggressive' | 'moderate' | 'minimal';
+export interface KnowledgeItem {
+    category: KnowledgeCategory;
+    title: string;
+    content: string;
+    relevance: number;
+    evidence: string[];
+    tags: string[];
+    sources?: string[];
+}
+export declare const KnowledgeItemSchema: z.ZodObject<{
+    category: z.ZodEnum<["best-practices", "design-patterns", "anti-patterns", "technology-specific", "performance-considerations", "security-guidelines", "scalability-patterns", "testing-strategies"]>;
+    title: z.ZodString;
+    content: z.ZodString;
+    relevance: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString, "many">;
+    tags: z.ZodArray<z.ZodString, "many">;
+    sources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+    title: string;
+    content: string;
+    relevance: number;
+    evidence: string[];
+    tags: string[];
+    sources?: string[] | undefined;
+}, {
+    category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+    title: string;
+    content: string;
+    relevance: number;
+    evidence: string[];
+    tags: string[];
+    sources?: string[] | undefined;
+}>;
+export interface KnowledgeMetadata {
+    generatedAt: string;
+    generationTime: number;
+    cacheKey: string;
+    domains: ArchitecturalDomain[];
+    confidence: number;
+    version: string;
+}
+export interface DomainKnowledge {
+    domain: ArchitecturalDomain;
+    knowledge: KnowledgeItem[];
+    confidence: number;
+    timestamp: string;
+    sources: string[];
+    metadata: KnowledgeMetadata;
+}
+export declare const DomainKnowledgeSchema: z.ZodObject<{
+    domain: z.ZodEnum<["web-applications", "mobile-applications", "microservices", "database-design", "cloud-infrastructure", "devops-cicd", "security-patterns", "performance-optimization", "api-design", "data-architecture"]>;
+    knowledge: z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<["best-practices", "design-patterns", "anti-patterns", "technology-specific", "performance-considerations", "security-guidelines", "scalability-patterns", "testing-strategies"]>;
+        title: z.ZodString;
+        content: z.ZodString;
+        relevance: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString, "many">;
+        tags: z.ZodArray<z.ZodString, "many">;
+        sources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+        title: string;
+        content: string;
+        relevance: number;
+        evidence: string[];
+        tags: string[];
+        sources?: string[] | undefined;
+    }, {
+        category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+        title: string;
+        content: string;
+        relevance: number;
+        evidence: string[];
+        tags: string[];
+        sources?: string[] | undefined;
+    }>, "many">;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodString;
+    sources: z.ZodArray<z.ZodString, "many">;
+    metadata: z.ZodObject<{
+        generatedAt: z.ZodString;
+        generationTime: z.ZodNumber;
+        cacheKey: z.ZodString;
+        domains: z.ZodArray<z.ZodString, "many">;
+        confidence: z.ZodNumber;
+        version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        generatedAt: string;
+        generationTime: number;
+        cacheKey: string;
+        domains: string[];
+        version: string;
+    }, {
+        confidence: number;
+        generatedAt: string;
+        generationTime: number;
+        cacheKey: string;
+        domains: string[];
+        version: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    sources: string[];
+    domain: "web-applications" | "mobile-applications" | "microservices" | "database-design" | "cloud-infrastructure" | "devops-cicd" | "security-patterns" | "performance-optimization" | "api-design" | "data-architecture";
+    knowledge: {
+        category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+        title: string;
+        content: string;
+        relevance: number;
+        evidence: string[];
+        tags: string[];
+        sources?: string[] | undefined;
+    }[];
+    confidence: number;
+    timestamp: string;
+    metadata: {
+        confidence: number;
+        generatedAt: string;
+        generationTime: number;
+        cacheKey: string;
+        domains: string[];
+        version: string;
+    };
+}, {
+    sources: string[];
+    domain: "web-applications" | "mobile-applications" | "microservices" | "database-design" | "cloud-infrastructure" | "devops-cicd" | "security-patterns" | "performance-optimization" | "api-design" | "data-architecture";
+    knowledge: {
+        category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+        title: string;
+        content: string;
+        relevance: number;
+        evidence: string[];
+        tags: string[];
+        sources?: string[] | undefined;
+    }[];
+    confidence: number;
+    timestamp: string;
+    metadata: {
+        confidence: number;
+        generatedAt: string;
+        generationTime: number;
+        cacheKey: string;
+        domains: string[];
+        version: string;
+    };
+}>;
+export interface KnowledgeGenerationConfig {
+    domains?: ArchitecturalDomain[];
+    depth?: KnowledgeDepth;
+    cacheEnabled?: boolean;
+    cacheTTL?: number;
+    securityValidation?: boolean;
+    customTemplates?: DomainTemplate[];
+    maxKnowledgeItems?: number;
+    maxTokens?: number;
+    relevanceThreshold?: number;
+    parallelGeneration?: boolean;
+}
+export declare const KnowledgeGenerationConfigSchema: z.ZodObject<{
+    domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    depth: z.ZodOptional<z.ZodEnum<["basic", "intermediate", "advanced"]>>;
+    cacheEnabled: z.ZodOptional<z.ZodBoolean>;
+    cacheTTL: z.ZodOptional<z.ZodNumber>;
+    securityValidation: z.ZodOptional<z.ZodBoolean>;
+    customTemplates: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    maxKnowledgeItems: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    relevanceThreshold: z.ZodOptional<z.ZodNumber>;
+    parallelGeneration: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    domains?: string[] | undefined;
+    depth?: "basic" | "intermediate" | "advanced" | undefined;
+    cacheEnabled?: boolean | undefined;
+    cacheTTL?: number | undefined;
+    securityValidation?: boolean | undefined;
+    customTemplates?: any[] | undefined;
+    maxKnowledgeItems?: number | undefined;
+    maxTokens?: number | undefined;
+    relevanceThreshold?: number | undefined;
+    parallelGeneration?: boolean | undefined;
+}, {
+    domains?: string[] | undefined;
+    depth?: "basic" | "intermediate" | "advanced" | undefined;
+    cacheEnabled?: boolean | undefined;
+    cacheTTL?: number | undefined;
+    securityValidation?: boolean | undefined;
+    customTemplates?: any[] | undefined;
+    maxKnowledgeItems?: number | undefined;
+    maxTokens?: number | undefined;
+    relevanceThreshold?: number | undefined;
+    parallelGeneration?: boolean | undefined;
+}>;
+export interface ToolKnowledgeConfig {
+    enableKnowledgeGeneration: boolean;
+    domains: ArchitecturalDomain[];
+    knowledgeDepth: KnowledgeDepth;
+    cacheStrategy: CacheStrategy;
+    autoDetectDomains?: boolean;
+    customKnowledgeTemplates?: string[];
+}
+export interface ArchitecturalContext {
+    projectPath?: string;
+    technologies?: string[];
+    patterns?: string[];
+    existingAdrs?: string[];
+    projectType?: string;
+    teamSize?: number;
+    constraints?: string[];
+    goals?: string[];
+}
+export interface ProjectContext {
+    path: string;
+    name?: string;
+    description?: string;
+    technologies: string[];
+    fileTypes: string[];
+    directoryStructure: string[];
+    packageFiles: string[];
+    configFiles: string[];
+}
+export interface DomainTemplate {
+    domain: ArchitecturalDomain;
+    categories: TemplateCategoryDefinition[];
+    metadata: TemplateMetadata;
+}
+export interface TemplateCategoryDefinition {
+    category: KnowledgeCategory;
+    items: string[];
+    priority: number;
+    applicability: string[];
+}
+export interface TemplateMetadata {
+    version: string;
+    author: string;
+    lastUpdated: string;
+    description: string;
+    tags: string[];
+}
+export interface KnowledgeGenerationResult {
+    knowledgePrompt: PromptObject;
+    enhancedPrompt?: PromptObject;
+    domainKnowledge: DomainKnowledge[];
+    cacheKey: string;
+    metadata: GenerationMetadata;
+    securityCheck?: KnowledgeSecurityCheck;
+}
+export interface GenerationMetadata {
+    totalGenerationTime: number;
+    domainsProcessed: ArchitecturalDomain[];
+    knowledgeItemsGenerated: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageConfidence: number;
+    qualityScore: number;
+}
+export interface KnowledgeSecurityCheck {
+    contentSafety: boolean;
+    sourceReliability: number;
+    relevanceScore: number;
+    qualityScore: number;
+    warnings: string[];
+    recommendations: string[];
+    validationTime: number;
+}
+export interface KnowledgeValidationResult {
+    isValid: boolean;
+    confidence: number;
+    issues: ValidationIssue[];
+    suggestions: string[];
+    qualityMetrics: QualityMetrics;
+}
+export interface ValidationIssue {
+    type: 'error' | 'warning' | 'info';
+    category: string;
+    message: string;
+    severity: number;
+    suggestion?: string;
+}
+export interface QualityMetrics {
+    completeness: number;
+    accuracy: number;
+    relevance: number;
+    clarity: number;
+    actionability: number;
+}
+export interface KnowledgeCacheEntry {
+    key: string;
+    domainKnowledge: DomainKnowledge[];
+    generatedAt: string;
+    expiresAt: string;
+    accessCount: number;
+    lastAccessed: string;
+    size: number;
+    metadata: CacheEntryMetadata;
+}
+export interface CacheEntryMetadata {
+    domains: ArchitecturalDomain[];
+    config: KnowledgeGenerationConfig;
+    contextHash: string;
+    version: string;
+    compressionUsed: boolean;
+}
+export interface KnowledgePerformanceMetrics {
+    generationTime: number;
+    cacheHitRate: number;
+    averageKnowledgeQuality: number;
+    memoryUsage: number;
+    concurrentGenerations: number;
+    errorRate: number;
+}
+export interface KnowledgeIntegrationOptions {
+    combineWithOriginalPrompt: boolean;
+    knowledgeWeight: number;
+    formatAsContext: boolean;
+    includeMetadata: boolean;
+    customIntegrationTemplate?: string;
+}
+export interface DomainDetectionResult {
+    detectedDomains: ArchitecturalDomain[];
+    confidence: number;
+    evidence: DomainEvidence[];
+    recommendations: string[];
+    fallbackDomains: ArchitecturalDomain[];
+}
+export interface DomainEvidence {
+    domain: ArchitecturalDomain;
+    evidence: string[];
+    confidence: number;
+    sources: string[];
+}
+export interface KnowledgeGenerationError {
+    code: string;
+    message: string;
+    domain?: ArchitecturalDomain;
+    context?: any;
+    timestamp: string;
+    recoverable: boolean;
+}
+export interface KnowledgeGenerationStatus {
+    status: 'pending' | 'generating' | 'completed' | 'failed' | 'cached';
+    progress: number;
+    currentDomain?: ArchitecturalDomain;
+    estimatedTimeRemaining?: number;
+    errors: KnowledgeGenerationError[];
+}
+export declare const ArchitecturalContextSchema: z.ZodObject<{
+    projectPath: z.ZodOptional<z.ZodString>;
+    technologies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    existingAdrs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    projectType: z.ZodOptional<z.ZodString>;
+    teamSize: z.ZodOptional<z.ZodNumber>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    goals: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    projectPath?: string | undefined;
+    technologies?: string[] | undefined;
+    patterns?: string[] | undefined;
+    existingAdrs?: string[] | undefined;
+    projectType?: string | undefined;
+    teamSize?: number | undefined;
+    constraints?: string[] | undefined;
+    goals?: string[] | undefined;
+}, {
+    projectPath?: string | undefined;
+    technologies?: string[] | undefined;
+    patterns?: string[] | undefined;
+    existingAdrs?: string[] | undefined;
+    projectType?: string | undefined;
+    teamSize?: number | undefined;
+    constraints?: string[] | undefined;
+    goals?: string[] | undefined;
+}>;
+export declare const KnowledgeGenerationResultSchema: z.ZodObject<{
+    knowledgePrompt: z.ZodObject<{
+        prompt: z.ZodString;
+        instructions: z.ZodString;
+        context: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    }, {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    }>;
+    enhancedPrompt: z.ZodOptional<z.ZodObject<{
+        prompt: z.ZodString;
+        instructions: z.ZodString;
+        context: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    }, {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    }>>;
+    domainKnowledge: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<["web-applications", "mobile-applications", "microservices", "database-design", "cloud-infrastructure", "devops-cicd", "security-patterns", "performance-optimization", "api-design", "data-architecture"]>;
+        knowledge: z.ZodArray<z.ZodObject<{
+            category: z.ZodEnum<["best-practices", "design-patterns", "anti-patterns", "technology-specific", "performance-considerations", "security-guidelines", "scalability-patterns", "testing-strategies"]>;
+            title: z.ZodString;
+            content: z.ZodString;
+            relevance: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodString, "many">;
+            tags: z.ZodArray<z.ZodString, "many">;
+            sources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+            title: string;
+            content: string;
+            relevance: number;
+            evidence: string[];
+            tags: string[];
+            sources?: string[] | undefined;
+        }, {
+            category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+            title: string;
+            content: string;
+            relevance: number;
+            evidence: string[];
+            tags: string[];
+            sources?: string[] | undefined;
+        }>, "many">;
+        confidence: z.ZodNumber;
+        timestamp: z.ZodString;
+        sources: z.ZodArray<z.ZodString, "many">;
+        metadata: z.ZodObject<{
+            generatedAt: z.ZodString;
+            generationTime: z.ZodNumber;
+            cacheKey: z.ZodString;
+            domains: z.ZodArray<z.ZodString, "many">;
+            confidence: z.ZodNumber;
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            generatedAt: string;
+            generationTime: number;
+            cacheKey: string;
+            domains: string[];
+            version: string;
+        }, {
+            confidence: number;
+            generatedAt: string;
+            generationTime: number;
+            cacheKey: string;
+            domains: string[];
+            version: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        sources: string[];
+        domain: "web-applications" | "mobile-applications" | "microservices" | "database-design" | "cloud-infrastructure" | "devops-cicd" | "security-patterns" | "performance-optimization" | "api-design" | "data-architecture";
+        knowledge: {
+            category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+            title: string;
+            content: string;
+            relevance: number;
+            evidence: string[];
+            tags: string[];
+            sources?: string[] | undefined;
+        }[];
+        confidence: number;
+        timestamp: string;
+        metadata: {
+            confidence: number;
+            generatedAt: string;
+            generationTime: number;
+            cacheKey: string;
+            domains: string[];
+            version: string;
+        };
+    }, {
+        sources: string[];
+        domain: "web-applications" | "mobile-applications" | "microservices" | "database-design" | "cloud-infrastructure" | "devops-cicd" | "security-patterns" | "performance-optimization" | "api-design" | "data-architecture";
+        knowledge: {
+            category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+            title: string;
+            content: string;
+            relevance: number;
+            evidence: string[];
+            tags: string[];
+            sources?: string[] | undefined;
+        }[];
+        confidence: number;
+        timestamp: string;
+        metadata: {
+            confidence: number;
+            generatedAt: string;
+            generationTime: number;
+            cacheKey: string;
+            domains: string[];
+            version: string;
+        };
+    }>, "many">;
+    cacheKey: z.ZodString;
+    metadata: z.ZodObject<{
+        totalGenerationTime: z.ZodNumber;
+        domainsProcessed: z.ZodArray<z.ZodString, "many">;
+        knowledgeItemsGenerated: z.ZodNumber;
+        cacheHits: z.ZodNumber;
+        cacheMisses: z.ZodNumber;
+        averageConfidence: z.ZodNumber;
+        qualityScore: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        totalGenerationTime: number;
+        domainsProcessed: string[];
+        knowledgeItemsGenerated: number;
+        cacheHits: number;
+        cacheMisses: number;
+        averageConfidence: number;
+        qualityScore: number;
+    }, {
+        totalGenerationTime: number;
+        domainsProcessed: string[];
+        knowledgeItemsGenerated: number;
+        cacheHits: number;
+        cacheMisses: number;
+        averageConfidence: number;
+        qualityScore: number;
+    }>;
+    securityCheck: z.ZodOptional<z.ZodObject<{
+        contentSafety: z.ZodBoolean;
+        sourceReliability: z.ZodNumber;
+        relevanceScore: z.ZodNumber;
+        qualityScore: z.ZodNumber;
+        warnings: z.ZodArray<z.ZodString, "many">;
+        recommendations: z.ZodArray<z.ZodString, "many">;
+        validationTime: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        qualityScore: number;
+        contentSafety: boolean;
+        sourceReliability: number;
+        relevanceScore: number;
+        warnings: string[];
+        recommendations: string[];
+        validationTime: number;
+    }, {
+        qualityScore: number;
+        contentSafety: boolean;
+        sourceReliability: number;
+        relevanceScore: number;
+        warnings: string[];
+        recommendations: string[];
+        validationTime: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    metadata: {
+        totalGenerationTime: number;
+        domainsProcessed: string[];
+        knowledgeItemsGenerated: number;
+        cacheHits: number;
+        cacheMisses: number;
+        averageConfidence: number;
+        qualityScore: number;
+    };
+    cacheKey: string;
+    knowledgePrompt: {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    };
+    domainKnowledge: {
+        sources: string[];
+        domain: "web-applications" | "mobile-applications" | "microservices" | "database-design" | "cloud-infrastructure" | "devops-cicd" | "security-patterns" | "performance-optimization" | "api-design" | "data-architecture";
+        knowledge: {
+            category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+            title: string;
+            content: string;
+            relevance: number;
+            evidence: string[];
+            tags: string[];
+            sources?: string[] | undefined;
+        }[];
+        confidence: number;
+        timestamp: string;
+        metadata: {
+            confidence: number;
+            generatedAt: string;
+            generationTime: number;
+            cacheKey: string;
+            domains: string[];
+            version: string;
+        };
+    }[];
+    enhancedPrompt?: {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    } | undefined;
+    securityCheck?: {
+        qualityScore: number;
+        contentSafety: boolean;
+        sourceReliability: number;
+        relevanceScore: number;
+        warnings: string[];
+        recommendations: string[];
+        validationTime: number;
+    } | undefined;
+}, {
+    metadata: {
+        totalGenerationTime: number;
+        domainsProcessed: string[];
+        knowledgeItemsGenerated: number;
+        cacheHits: number;
+        cacheMisses: number;
+        averageConfidence: number;
+        qualityScore: number;
+    };
+    cacheKey: string;
+    knowledgePrompt: {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    };
+    domainKnowledge: {
+        sources: string[];
+        domain: "web-applications" | "mobile-applications" | "microservices" | "database-design" | "cloud-infrastructure" | "devops-cicd" | "security-patterns" | "performance-optimization" | "api-design" | "data-architecture";
+        knowledge: {
+            category: "best-practices" | "design-patterns" | "anti-patterns" | "technology-specific" | "performance-considerations" | "security-guidelines" | "scalability-patterns" | "testing-strategies";
+            title: string;
+            content: string;
+            relevance: number;
+            evidence: string[];
+            tags: string[];
+            sources?: string[] | undefined;
+        }[];
+        confidence: number;
+        timestamp: string;
+        metadata: {
+            confidence: number;
+            generatedAt: string;
+            generationTime: number;
+            cacheKey: string;
+            domains: string[];
+            version: string;
+        };
+    }[];
+    enhancedPrompt?: {
+        prompt: string;
+        instructions: string;
+        context?: any;
+    } | undefined;
+    securityCheck?: {
+        qualityScore: number;
+        contentSafety: boolean;
+        sourceReliability: number;
+        relevanceScore: number;
+        warnings: string[];
+        recommendations: string[];
+        validationTime: number;
+    } | undefined;
+}>;
+//# sourceMappingURL=knowledge-generation.d.ts.map

package/dist/src/types/knowledge-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-generation.d.ts","sourceRoot":"","sources":["../../../src/types/knowledge-generation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,GAAG,CAAC;CACd;AAMD,MAAM,MAAM,mBAAmB,GAC3B,kBAAkB,GAClB,qBAAqB,GACrB,eAAe,GACf,iBAAiB,GACjB,sBAAsB,GACtB,aAAa,GACb,mBAAmB,GACnB,0BAA0B,GAC1B,YAAY,GACZ,mBAAmB,CAAC;AAExB,MAAM,MAAM,iBAAiB,GACzB,gBAAgB,GAChB,iBAAiB,GACjB,eAAe,GACf,qBAAqB,GACrB,4BAA4B,GAC5B,qBAAqB,GACrB,sBAAsB,GACtB,oBAAoB,CAAC;AAEzB,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,cAAc,GAAG,UAAU,CAAC;AACnE,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC;AAMlE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;EAiB9B,CAAC;AAEH,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBhC,CAAC;AAMH,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAChC,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IACnC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1C,CAAC;AAEH,MAAM,WAAW,mBAAmB;IAClC,yBAAyB,EAAE,OAAO,CAAC;IACnC,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;CACrC;AAMD,MAAM,WAAW,oBAAoB;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAMD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,EAAE,0BAA0B,EAAE,CAAC;IACzC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB;IACxC,eAAe,EAAE,YAAY,CAAC;IAC9B,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,aAAa,CAAC,EAAE,sBAAsB,CAAC;CACxC;AAED,MAAM,WAAW,kBAAkB;IACjC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,mBAAmB,EAAE,CAAC;IACxC,uBAAuB,EAAE,MAAM,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAMD,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACvB;AAMD,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,MAAM,EAAE,yBAAyB,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,uBAAuB,EAAE,MAAM,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD,MAAM,WAAW,2BAA2B;IAC1C,yBAAyB,EAAE,OAAO,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,eAAe,EAAE,mBAAmB,EAAE,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,mBAAmB,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAMD,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,MAAM,EAAE,wBAAwB,EAAE,CAAC;CACpC;AAMD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B1C,CAAC"}