@aaswe/codebase-ai/dist/services/layer3/index.d.ts

AI-Assisted Software Engineering (AASWE) - Rich codebase context for IDE LLMs

/**
 * Layer 3: AI/LLM Integration & Reasoning - Main Integration
 *
 * This module provides the main integration point for Layer 3 services,
 * combining RAG Engine, GraphCypher QA, and SPARQL Query Engine into
 * a unified AI reasoning system.
 */
export { RAGEngine, ContextManager } from './langchain-rag';
export { GraphCypherQAChain } from './graph-cypher-qa';
export { SPARQLQueryEngine } from './sparql-query-engine';
export type { RAGConfig, QueryContext, RAGResponse, RAGMetrics } from './langchain-rag/types';
export type { CypherQAConfig, CypherQAResponse, CypherQAMetrics } from './graph-cypher-qa/types';
export type { SPARQLEngineConfig, SPARQLQueryResponse, SPARQLQueryIntent, ParsedSPARQLQuery, GeneratedSPARQLQuery, SPARQLExecutionResult } from './sparql-query-engine/types';
import { EventEmitter } from 'events';
import { InMemoryRDFStore } from '../layer2/in-memory-rdf';
import { Neo4jDatabaseService } from '../layer2/neo4j-database';
export interface Layer3Config {
    rag: {
        provider: 'openai' | 'local';
        model: string;
        apiKey?: string;
        baseURL?: string;
        temperature?: number;
        maxTokens?: number;
    };
    graphCypher: {
        neo4jUrl: string;
        username?: string;
        password?: string;
        database?: string;
    };
    sparql: {
        provider: 'openai' | 'local';
        model: string;
        apiKey?: string;
        baseURL?: string;
    };
}
export interface AIQueryRequest {
    query: string;
    type: 'rag' | 'cypher' | 'sparql' | 'auto';
    context?: {
        currentFile?: string;
        selectedText?: string;
        projectPath?: string;
    };
}
export interface AIQueryResponse {
    query: string;
    type: 'rag' | 'cypher' | 'sparql';
    response: string;
    confidence: number;
    sources?: string[];
    executionTime: number;
    metadata?: Record<string, any>;
}
/**
 * Layer 3 AI Integration Service
 *
 * Provides unified access to all Layer 3 AI services with intelligent
 * query routing and response coordination.
 */
export declare class Layer3AIService extends EventEmitter {
    private config;
    private ragEngine?;
    private graphCypherQA?;
    private sparqlEngine?;
    private rdfStore;
    private neo4jService;
    private isInitialized;
    constructor(config: Layer3Config, rdfStore: InMemoryRDFStore, neo4jService: Neo4jDatabaseService);
    /**
     * Initialize all Layer 3 services
     */
    initialize(): Promise<void>;
    /**
     * Process AI query with intelligent routing
     */
    query(request: AIQueryRequest): Promise<AIQueryResponse>;
    /**
     * Determine appropriate query type based on query content
     */
    private determineQueryType;
    /**
     * Process RAG query
     */
    private processRAGQuery;
    /**
     * Process Cypher query
     */
    private processCypherQuery;
    /**
     * Process SPARQL query
     */
    private processSPARQLQuery;
    /**
     * Get service health status
     */
    getHealth(): Promise<{
        status: 'healthy' | 'degraded' | 'unhealthy';
        services: {
            rag: boolean;
            cypher: boolean;
            sparql: boolean;
        };
    }>;
    /**
     * Get combined metrics from all services
     */
    getMetrics(): {
        rag: Promise<import("./langchain-rag").RAGMetrics> | undefined;
        cypher: Promise<import("./graph-cypher-qa").CypherQAMetrics> | undefined;
        sparql: import("./sparql-query-engine").SPARQLMetrics | undefined;
    };
    /**
     * Shutdown all services
     */
    shutdown(): Promise<void>;
}
//# sourceMappingURL=index.d.ts.map