csvlod-ai-mcp-server/dist/multimodal-processor.d.ts

CSVLOD-AI MCP Server v3.0 with Quantum Context Intelligence - Revolutionary Context Intelligence Engine and Multimodal Processor for sovereign AI development

/**
 * CSVLOD-AI Framework v3.0 - Multimodal Processor
 * Process and understand non-text content including diagrams, images, and media
 */
export interface MultiModalContent {
    id: string;
    type: ContentType;
    filePath: string;
    metadata: ContentMetadata;
    extractedData: ExtractedData;
    relationships: string[];
    processingStatus: ProcessingStatus;
}
export interface ExtractedData {
    text?: string;
    structure?: StructureData;
    components?: ComponentData[];
    relationships?: RelationshipData[];
    concepts?: ConceptData[];
}
export interface DiagramStructure {
    type: DiagramType;
    components: DiagramComponent[];
    connections: DiagramConnection[];
    metadata: DiagramMetadata;
}
export interface ArchitectureMap {
    systems: System[];
    interfaces: Interface[];
    dataFlows: DataFlow[];
    deploymentUnits: DeploymentUnit[];
}
export declare enum ContentType {
    IMAGE = "image",
    DIAGRAM = "diagram",
    DOCUMENT = "document",
    VIDEO = "video",
    AUDIO = "audio"
}
export declare enum DiagramType {
    ARCHITECTURE = "architecture",
    SEQUENCE = "sequence",
    ENTITY_RELATIONSHIP = "entity_relationship",
    FLOW_CHART = "flow_chart",
    NETWORK = "network",
    UML_CLASS = "uml_class",
    C4_SYSTEM = "c4_system",
    MERMAID = "mermaid"
}
export declare enum ProcessingStatus {
    PENDING = "pending",
    PROCESSING = "processing",
    COMPLETED = "completed",
    ERROR = "error"
}
interface ContentMetadata {
    fileName: string;
    fileSize: number;
    mimeType: string;
    dimensions?: {
        width: number;
        height: number;
    };
    duration?: number;
    createdAt: Date;
    lastModified: Date;
}
interface StructureData {
    sections: Section[];
    headings: Heading[];
    lists: List[];
    tables: Table[];
    codeBlocks: CodeBlock[];
}
interface ComponentData {
    name: string;
    type: string;
    properties: Record<string, any>;
    position?: {
        x: number;
        y: number;
    };
    size?: {
        width: number;
        height: number;
    };
}
interface RelationshipData {
    source: string;
    target: string;
    type: string;
    label?: string;
    properties?: Record<string, any>;
}
interface ConceptData {
    term: string;
    confidence: number;
    context: string;
    category: string;
}
interface DiagramComponent {
    id: string;
    name: string;
    type: string;
    position: {
        x: number;
        y: number;
    };
    size: {
        width: number;
        height: number;
    };
    properties: Record<string, any>;
}
interface DiagramConnection {
    id: string;
    source: string;
    target: string;
    type: string;
    label?: string;
    path?: {
        x: number;
        y: number;
    }[];
}
interface DiagramMetadata {
    title?: string;
    description?: string;
    author?: string;
    version?: string;
    tags: string[];
}
interface System {
    id: string;
    name: string;
    type: string;
    description?: string;
    responsibilities: string[];
    interfaces: string[];
}
interface Interface {
    id: string;
    name: string;
    type: string;
    protocol?: string;
    endpoints?: string[];
    dataFormats: string[];
}
interface DataFlow {
    id: string;
    source: string;
    target: string;
    dataType: string;
    frequency?: string;
    volume?: string;
}
interface DeploymentUnit {
    id: string;
    name: string;
    type: string;
    environment: string;
    resources?: Record<string, any>;
}
interface Section {
    title: string;
    content: string;
    level: number;
    subsections: Section[];
}
interface Heading {
    text: string;
    level: number;
    id?: string;
}
interface List {
    type: 'ordered' | 'unordered';
    items: string[];
}
interface Table {
    headers: string[];
    rows: string[][];
    caption?: string;
}
interface CodeBlock {
    language?: string;
    code: string;
    startLine?: number;
}
/**
 * Multimodal Processor - Core implementation
 */
export declare class MultiModalProcessor {
    private projectRoot;
    private configPath;
    private supportedFormats;
    private processingQueue;
    private cache;
    constructor(projectRoot: string);
    /**
     * Initialize the Multimodal Processor
     */
    private initializeProcessor;
    /**
     * Scan project for multimodal content
     */
    private scanMultimodalContent;
    /**
     * Find multimodal files in project
     */
    private findMultimodalFiles;
    /**
     * Process multimodal content
     */
    processContent(filePath: string): Promise<MultiModalContent>;
    /**
     * Process image content
     */
    private processImage;
    /**
     * Process SVG diagrams
     */
    private processSVGDiagram;
    /**
     * Extract text from images (OCR simulation)
     */
    private extractImageText;
    /**
     * Process diagram content
     */
    private processDiagram;
    /**
     * Process Mermaid diagrams
     */
    private processMermaidDiagram;
    /**
     * Process PlantUML diagrams
     */
    private processPlantUMLDiagram;
    /**
     * Process document content
     */
    private processDocument;
    /**
     * Process Markdown documents
     */
    private processMarkdownDocument;
    /**
     * Process HTML documents
     */
    private processHTMLDocument;
    /**
     * Utility methods
     */
    private generateContentId;
    private getMimeType;
    private identifyDiagramType;
    private identifyMermaidDiagramType;
    private extractMermaidComponents;
    private extractMermaidConnections;
    private extractMermaidTitle;
    private extractPlantUMLComponents;
    private parseMarkdownStructure;
    private convertDiagramToStructure;
    private extractConceptsFromText;
    private saveProcessingResult;
    /**
     * Get all processed multimodal content
     */
    getAllContent(): MultiModalContent[];
    /**
     * Get content by ID
     */
    getContent(id: string): MultiModalContent | undefined;
    /**
     * Search content by type
     */
    getContentByType(type: ContentType): MultiModalContent[];
    /**
     * Get processing statistics
     */
    getProcessingStats(): {
        total: number;
        byType: Record<string, number>;
        byStatus: Record<string, number>;
    };
}
export default MultiModalProcessor;
//# sourceMappingURL=multimodal-processor.d.ts.map