mcp-adr-analysis-server/dist/src/types/knowledge-generation.d.ts

MCP server for analyzing Architectural Decision Records and project architecture

/**
 * 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