mnemos-coder/dist/tools/ContextAssembly.d.ts

CLI-based coding agent with graph-based execution loop and terminal UI

/**
 * Dynamic context assembly system with JIT loading and intelligent caching
 */
import { EventEmitter } from 'events';
import { MnemosState } from '../core/state.js';
export interface ContextRequest {
    id: string;
    query: string;
    type: 'file_context' | 'semantic_search' | 'dependency_analysis' | 'impact_assessment';
    priority: number;
    scope: 'local' | 'module' | 'project';
    max_results?: number;
    include_dependencies?: boolean;
    cache_duration?: number;
}
export interface ContextFragment {
    id: string;
    type: 'code' | 'documentation' | 'dependency' | 'test' | 'config';
    content: string;
    metadata: {
        file_path: string;
        language: string;
        size: number;
        last_modified: number;
        relevance_score: number;
        dependencies: string[];
        tags: string[];
    };
    relationships: Array<{
        target_id: string;
        type: 'imports' | 'calls' | 'extends' | 'references' | 'tests';
        strength: number;
    }>;
}
export interface AssembledContext {
    request_id: string;
    fragments: ContextFragment[];
    total_relevance: number;
    assembly_time: number;
    cache_hit_ratio: number;
    recommendations: Array<{
        type: 'include_file' | 'explore_dependency' | 'check_tests' | 'review_docs';
        description: string;
        priority: number;
    }>;
}
export interface ContextGraph {
    nodes: Map<string, ContextFragment>;
    edges: Array<{
        from: string;
        to: string;
        type: string;
        weight: number;
    }>;
    clusters: Array<{
        id: string;
        fragments: string[];
        theme: string;
        coherence_score: number;
    }>;
}
export declare class ContextAssemblyEngine extends EventEmitter {
    private workspace;
    private contextExplorer;
    private codeAnalyzer;
    private fragmentCache;
    private assemblyCache;
    private dependencyCache;
    private contextGraph;
    private requestHistory;
    constructor(workspace: string, options?: {
        cache_size?: number;
        cache_ttl?: number;
    });
    /**
     * Assemble context for a given request with intelligent caching and JIT loading
     */
    assembleContext(request: ContextRequest): Promise<AssembledContext>;
    /**
     * Preload context for anticipated requests
     */
    preloadContext(predictedRequests: ContextRequest[], priority?: 'low' | 'medium' | 'high'): Promise<void>;
    /**
     * Intelligent context prediction based on usage patterns
     */
    predictNextContext(currentRequest: ContextRequest, state: MnemosState): ContextRequest[];
    /**
     * Update context graph with new information
     */
    updateContextGraph(fragments: ContextFragment[]): Promise<void>;
    /**
     * Get relevant context for code editing operations
     */
    getEditingContext(targetFiles: string[], editType: 'create' | 'modify' | 'delete' | 'refactor'): Promise<AssembledContext>;
    /**
     * Create focused context for AI model consumption
     */
    createFocusedContext(assembled: AssembledContext, maxTokens?: number, priorityTypes?: string[]): {
        context: string;
        included_fragments: string[];
        token_count: number;
    };
    private gatherBaseFragments;
    private expandContext;
    private rankFragments;
    private filterFragments;
    private generateRecommendations;
    private generateEditingRecommendations;
    private generateCacheKey;
    private isCacheValid;
    private calculateCacheHitRatio;
    private codeContextToFragment;
    private inferFragmentType;
    private loadFragment;
    private findRelatedFragments;
    private updateClusters;
    private analyzeHistoricalPatterns;
    private estimateTokenCount;
    private formatFragmentForAI;
    private getBasePath;
    private getModuleRoot;
}
export declare function createContextAssemblyEngine(workspace: string): ContextAssemblyEngine;
//# sourceMappingURL=ContextAssembly.d.ts.map