il2cpp-dump-analyzer-mcp/dist/mcp/tools/analyze-dependencies-tool.d.ts

Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games

/**
 * Analyze Dependencies Tool Implementation
 * Performs comprehensive dependency analysis for IL2CPP classes
 */
import { z } from 'zod';
import { BaseAnalysisToolHandler, ToolExecutionContext } from '../base-tool-handler';
import { ValidationResult } from '../../utils/parameter-validator';
import { MCPResponse } from '../../utils/mcp-response-formatter';
/**
 * Analyze dependencies parameters interface
 */
interface AnalyzeDependenciesParams {
    class_name: string;
    analysis_type?: 'incoming' | 'outgoing' | 'bidirectional' | 'circular';
    depth?: number;
    include_system_types?: boolean;
}
/**
 * Dependency node interface
 */
interface DependencyNode {
    name: string;
    fullName: string;
    namespace: string;
    type: 'class' | 'interface' | 'enum';
    relationship: 'inheritance' | 'interface' | 'field' | 'method_parameter' | 'method_return' | 'generic_parameter';
    depth: number;
    isSystemType: boolean;
}
/**
 * Dependency analysis result interface
 */
interface DependencyAnalysisResult {
    targetClass: {
        name: string;
        fullName: string;
        namespace: string;
    };
    incomingDependencies: DependencyNode[];
    outgoingDependencies: DependencyNode[];
    circularDependencies: Array<{
        path: string[];
        description: string;
    }>;
    metrics: {
        totalIncoming: number;
        totalOutgoing: number;
        systemTypeCount: number;
        userTypeCount: number;
        couplingScore: number;
        maxDepthReached: number;
    };
    analysisMetadata: {
        analysisType: string;
        requestedDepth: number;
        actualDepth: number;
        includeSystemTypes: boolean;
        timestamp: string;
    };
}
/**
 * Analyze Dependencies Tool Handler
 * Performs comprehensive dependency mapping and analysis for IL2CPP classes
 */
export declare class AnalyzeDependenciesToolHandler extends BaseAnalysisToolHandler<AnalyzeDependenciesParams, DependencyAnalysisResult> {
    constructor(context: ToolExecutionContext);
    /**
     * Validate dependency analysis parameters
     */
    protected validateParameters(params: AnalyzeDependenciesParams): Promise<ValidationResult>;
    /**
     * Execute dependency analysis
     */
    protected executeCore(params: AnalyzeDependenciesParams): Promise<DependencyAnalysisResult>;
    /**
     * Analyze outgoing dependencies (what this class depends on)
     */
    private analyzeOutgoingDependencies;
    /**
     * Analyze incoming dependencies (what depends on this class)
     */
    private analyzeIncomingDependencies;
    /**
     * Detect circular dependencies
     */
    private detectCircularDependencies;
    /**
     * Calculate dependency metrics
     */
    private calculateDependencyMetrics;
    /**
     * Handle class not found error specifically
     */
    protected handleError(error: any, params?: AnalyzeDependenciesParams): MCPResponse;
}
/**
 * Zod schema for analyze dependencies tool parameters
 */
export declare const analyzeDependenciesSchema: z.ZodObject<{
    class_name: z.ZodString;
    analysis_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["incoming", "outgoing", "bidirectional", "circular"]>>>;
    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
    include_system_types: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    depth: number;
    class_name: string;
    analysis_type: "incoming" | "outgoing" | "bidirectional" | "circular";
    include_system_types: boolean;
}, {
    class_name: string;
    depth?: number | undefined;
    analysis_type?: "incoming" | "outgoing" | "bidirectional" | "circular" | undefined;
    include_system_types?: boolean | undefined;
}>;
/**
 * Factory function to create and register the analyze dependencies tool
 */
export declare function createAnalyzeDependenciesTool(server: any, context: ToolExecutionContext): AnalyzeDependenciesToolHandler;
export {};