bc-code-intelligence-mcp/dist/types/bc-knowledge.d.ts

BC Code Intelligence MCP Server - Complete Specialist Bundle with AI-driven expert consultation, seamless handoffs, and context-preserving workflows

import { z } from 'zod';
/**
 * Business Central Knowledge Base Types
 *
 * These types define the structure of our atomic BC knowledge topics,
 * indexes, and relationships for intelligent AI consumption.
 */
export declare const AtomicTopicFrontmatterSchema: z.ZodObject<{
    title: z.ZodOptional<z.ZodString>;
    domain: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
    difficulty: z.ZodOptional<z.ZodEnum<["beginner", "intermediate", "advanced", "expert"]>>;
    bc_versions: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    prerequisites: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    related_topics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    samples: z.ZodOptional<z.ZodString>;
    estimated_time: z.ZodOptional<z.ZodString>;
    type: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    pattern_type: z.ZodOptional<z.ZodEnum<["good", "bad", "unknown"]>>;
    regex_patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    description: z.ZodOptional<z.ZodString>;
    category: z.ZodOptional<z.ZodString>;
    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
    impact_level: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
    detection_confidence: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
    workflow_type: z.ZodOptional<z.ZodString>;
    phases: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
    conditional_mcp: z.ZodOptional<z.ZodString>;
    conditional_mcp_missing: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    name?: string;
    description?: string;
    type?: string;
    workflow_type?: string;
    title?: string;
    domain?: string | string[];
    difficulty?: "beginner" | "intermediate" | "advanced" | "expert";
    bc_versions?: string;
    tags?: string[];
    prerequisites?: string[];
    related_topics?: string[];
    samples?: string;
    estimated_time?: string;
    pattern_type?: "unknown" | "good" | "bad";
    regex_patterns?: string[];
    category?: string;
    severity?: "low" | "medium" | "high" | "critical";
    impact_level?: "low" | "medium" | "high";
    detection_confidence?: "low" | "medium" | "high";
    phases?: any[];
    conditional_mcp?: string;
    conditional_mcp_missing?: string;
}, {
    name?: string;
    description?: string;
    type?: string;
    workflow_type?: string;
    title?: string;
    domain?: string | string[];
    difficulty?: "beginner" | "intermediate" | "advanced" | "expert";
    bc_versions?: string;
    tags?: string[];
    prerequisites?: string[];
    related_topics?: string[];
    samples?: string;
    estimated_time?: string;
    pattern_type?: "unknown" | "good" | "bad";
    regex_patterns?: string[];
    category?: string;
    severity?: "low" | "medium" | "high" | "critical";
    impact_level?: "low" | "medium" | "high";
    detection_confidence?: "low" | "medium" | "high";
    phases?: any[];
    conditional_mcp?: string;
    conditional_mcp_missing?: string;
}>;
export type AtomicTopicFrontmatter = z.infer<typeof AtomicTopicFrontmatterSchema>;
export interface AtomicTopic {
    id: string;
    title: string;
    filePath: string;
    frontmatter: AtomicTopicFrontmatter;
    content: string;
    wordCount: number;
    lastModified: Date;
    samples?: {
        filePath: string;
        content: string;
    };
}
export interface TagIndex {
    tag: string;
    topics: string[];
    count: number;
}
export declare const DomainInfoSchema: z.ZodObject<{
    title: z.ZodString;
    description: z.ZodString;
    topic_count: z.ZodNumber;
    subdirectories: z.ZodArray<z.ZodString, "many">;
    key_topics: z.ZodArray<z.ZodString, "many">;
    difficulty_levels: z.ZodRecord<z.ZodString, z.ZodNumber>;
    tags: z.ZodArray<z.ZodString, "many">;
    sample_files: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    description?: string;
    title?: string;
    tags?: string[];
    topic_count?: number;
    subdirectories?: string[];
    key_topics?: string[];
    difficulty_levels?: Record<string, number>;
    sample_files?: number;
}, {
    description?: string;
    title?: string;
    tags?: string[];
    topic_count?: number;
    subdirectories?: string[];
    key_topics?: string[];
    difficulty_levels?: Record<string, number>;
    sample_files?: number;
}>;
export type DomainInfo = z.infer<typeof DomainInfoSchema>;
export interface DomainCatalog {
    domains: Record<string, DomainInfo>;
    global_statistics: {
        total_atomic_topics: number;
        total_domains: number;
        total_sample_files: number;
        average_topics_per_domain: number;
        most_common_tags: Array<{
            tag: string;
            count: number;
        }>;
        difficulty_distribution: Record<string, number>;
        bc_version_support: Record<string, number>;
    };
    generation_metadata: {
        generated_at: string;
        pipeline_version: string;
        atomic_topics_validated: boolean;
        tag_indexes_generated: number;
        quality_score: number;
    };
}
export interface TopicRelationship {
    prerequisites: string[];
    related_topics: string[];
    enables: string[];
    difficulty_progression: string;
    domain: string;
}
export interface TopicRelationships {
    topic_relationships: Record<string, TopicRelationship>;
    relationship_types: Record<string, string>;
    learning_pathways: Record<string, string[]>;
    cross_domain_connections: Record<string, Record<string, string[]>>;
    metadata: {
        generated_at: string;
        total_mapped_topics: number;
        relationship_count: number;
        learning_pathways: number;
        cross_domain_connections: number;
    };
}
export interface BCVersionInfo {
    description: string;
    supported_topics: number;
    percentage: number;
    key_features: string[];
}
export interface BCVersionMatrix {
    bc_version_compatibility: {
        version_ranges: Record<string, BCVersionInfo>;
        feature_evolution: Record<string, Record<string, string>>;
        backward_compatibility: {
            breaking_changes: Array<{
                version: string;
                impact: string;
                affected_topics: string[];
                migration_path: string;
            }>;
            deprecated_features: Array<{
                version: string;
                feature: string;
                replacement: string;
                sunset_version: string;
            }>;
        };
        version_specific_topics: Record<string, string[]>;
    };
    compatibility_testing: {
        test_matrix: Record<string, {
            tested_versions: string[];
            success_rate: number;
            known_issues: number;
            last_tested: string;
        }>;
        testing_methodology: {
            compilation_test: string;
            functionality_test: string;
            performance_validation: string;
        };
    };
    metadata: {
        generated_at: string;
        total_topics_analyzed: number;
        versions_covered: number;
        compatibility_score: number;
        next_review_date: string;
    };
}
export interface TopicSearchParams {
    tags?: string[];
    domain?: string;
    specialist?: string;
    difficulty?: "beginner" | "intermediate" | "advanced" | "expert";
    code_context?: string;
    bc_version?: string | undefined;
    limit?: number;
}
export interface TopicSearchResult {
    id: string;
    title: string;
    domain: string;
    domains?: string[];
    specialist?: string;
    difficulty: string;
    relevance_score: number;
    summary: string;
    tags: string[];
    prerequisites: string[];
    estimated_time?: string | undefined;
}
export interface CodeAnalysisParams {
    code_snippet: string;
    analysis_type?: "performance" | "quality" | "security" | "patterns" | "comprehensive";
    suggest_topics?: boolean;
    bc_version?: string | undefined;
}
export interface CodeAnalysisResult {
    issues: Array<{
        type: "anti-pattern" | "optimization" | "best-practice" | "warning";
        severity: "low" | "medium" | "high" | "critical";
        description: string;
        line_number?: number;
        suggestion: string;
        related_topics: string[];
    }>;
    patterns_detected: string[];
    optimization_opportunities: Array<{
        description: string;
        impact: "low" | "medium" | "high";
        difficulty: "easy" | "moderate" | "complex";
        related_topics: string[];
    }>;
    suggested_topics: TopicSearchResult[];
}
export interface OptimizationWorkflowParams {
    scenario: string;
    current_approach?: string;
    target_performance?: string;
    constraints?: string[];
}
export interface OptimizationWorkflow {
    steps: Array<{
        step_number: number;
        title: string;
        description: string;
        related_topics: string[];
        validation_criteria: string[];
        estimated_time: string;
    }>;
    learning_path: string[];
    success_metrics: string[];
    common_pitfalls: string[];
}
export interface ALCodePattern {
    name: string;
    pattern_type: "good" | "bad" | "unknown";
    regex_patterns: RegExp[];
    description: string;
    related_topics: string[];
    severity?: "low" | "medium" | "high" | "critical";
    category?: string;
    impact_level?: "low" | "medium" | "high";
    detection_confidence?: "low" | "medium" | "high";
}
export interface BCKBConfig {
    knowledge_base_path: string;
    indexes_path: string;
    methodologies_path?: string;
    cache_size: number;
    max_search_results: number;
    default_bc_version: string;
    enable_fuzzy_search: boolean;
    search_threshold: number;
}
export declare function isDomainMatch(topicDomain: string | string[] | undefined, targetDomain: string): boolean;
export declare function getDomainList(domain: string | string[] | undefined): string[];
//# sourceMappingURL=bc-knowledge.d.ts.map