bc-code-intelligence-mcp/dist/layers/embedded-layer.d.ts

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

/**
 * Embedded Knowledge Layer
 *
 * Loads knowledge content from the embedded git submodule (embedded-knowledge/).
 * This is the base layer (Layer 0) that provides the core BC knowledge content.
 */
import { LayerLoadResult } from '../types/layer-types.js';
import { BaseKnowledgeLayer } from './base-layer.js';
import { SpecialistDefinition } from '../services/specialist-loader.js';
import { LayerContentType } from '../types/enhanced-layer-types.js';
export declare class EmbeddedKnowledgeLayer extends BaseKnowledgeLayer {
    private readonly embeddedPath;
    readonly supported_content_types: LayerContentType[];
    constructor(embeddedPath?: string);
    /**
     * Initialize the embedded layer by loading topics and indexes from submodule
     */
    initialize(): Promise<LayerLoadResult>;
    /**
     * Load all atomic topics from embedded knowledge (supports both domains/ and topics/)
     */
    protected loadTopics(): Promise<number>;
    /**
     * Load indexes from embedded knowledge
     */
    protected loadIndexes(): Promise<number>;
    /**
     * Load a single atomic topic from a markdown file
     */
    private loadAtomicTopic;
    /**
     * Load tag indexes from JSON files
     */
    private loadTagIndexes;
    /**
     * Load domain catalog
     */
    private loadDomainCatalog;
    /**
     * Load topic relationships
     */
    private loadTopicRelationships;
    /**
     * Load BC version matrix
     */
    private loadBCVersionMatrix;
    /**
     * Get an index by name
     */
    getIndex(indexName: string): any;
    /**
     * Get all available index names
     */
    getIndexNames(): string[];
    /**
     * Load all specialists from embedded knowledge specialists folder
     */
    protected loadSpecialists(): Promise<number>;
    /**
     * Load a single specialist from a markdown file
     */
    private loadSpecialist;
    /**
     * Validate specialist definition
     */
    private validateSpecialist;
    /**
     * Load methodologies from methodologies/ directory
     */
    protected loadMethodologies(): Promise<number>;
    /**
     * Check if the layer has a specific specialist
     */
    hasSpecialist(specialistId: string): boolean;
    /**
     * Get a specialist from this layer
     */
    getSpecialist(specialistId: string): SpecialistDefinition | null;
    /**
     * Get all specialist IDs available in this layer
     */
    getSpecialistIds(): string[];
    /**
     * Get all specialists from this layer
     */
    getAllSpecialists(): SpecialistDefinition[];
    /**
     * Search for specialists within this layer
     */
    protected searchSpecialists(query: string, limit?: number): SpecialistDefinition[];
    /**
     * Get specialist statistics for this layer
     */
    getSpecialistStatistics(): {
        total_specialists: number;
        teams: Record<string, number>;
        domains: Record<string, number>;
    };
    /**
     * Check if content exists by type and ID
     */
    hasContent<T extends LayerContentType>(type: T, id: string): boolean;
    /**
     * Get content by type and ID
     */
    getContent<T extends LayerContentType>(type: T, id: string): Promise<any>;
    /**
     * Get all content IDs for a specific type
     */
    getContentIds<T extends LayerContentType>(type: T): string[];
    /**
     * Search content within this layer by type
     */
    searchContent<T extends LayerContentType>(type: T, query: string, limit?: number): any[];
    /**
     * Get enhanced statistics with content type breakdown
     */
    getEnhancedStatistics(): {
        name: string;
        priority: number;
        content_counts: Record<LayerContentType, number>;
        load_time_ms?: number;
        initialized: boolean;
    };
    /**
     * Convert LayerLoadResult to EnhancedLayerLoadResult
     */
    private convertToEnhancedResult;
}
//# sourceMappingURL=embedded-layer.d.ts.map