@andrebuzeli/advanced-memory-markdown-mcp/dist/core/reasoning-tool.d.ts

Advanced Memory Bank MCP v3.1.5 - Sistema avançado de gerenciamento de memória com isolamento de projetos por IDE, sincronização sob demanda, backup a cada 30min, apenas arquivos .md principais sincronizados, pasta reasoning temporária com limpeza automát

/**
 * Advanced Coding Reasoning Tool v2.0
 * Specialized AI reasoning tool for coding problems, debugging, and software development
 *
 * Based on Chain-of-Thought prompting and interactive debugging best practices
 * Focuses specifically on coding-related reasoning and problem-solving
 */
export type CodingReasoningAction = 'analyze-code' | 'debug-step-by-step' | 'architecture-reasoning' | 'performance-analysis' | 'refactor-planning' | 'test-strategy' | 'error-investigation' | 'code-review' | 'cleanup' | 'status';
export interface CodeAnalysisRequest {
    code: string;
    language: string;
    context?: string;
    problem?: string;
    errorMessage?: string;
}
export interface ReasoningStep {
    stepNumber: number;
    type: 'observation' | 'hypothesis' | 'investigation' | 'conclusion' | 'action';
    content: string;
    codeSnippet?: string;
    reasoning: string;
    confidence: number;
    timestamp: number;
}
export interface CodingReasoningResult {
    id: string;
    problem: string;
    language: string;
    steps: ReasoningStep[];
    finalSolution: string;
    alternativeSolutions: string[];
    testCases: string[];
    performanceNotes: string[];
    securityConsiderations: string[];
    confidence: number;
    created: number;
}
export interface DebugSession {
    id: string;
    code: string;
    errorMessage: string;
    language: string;
    steps: DebugStep[];
    hypothesis: string[];
    investigation: string[];
    solution?: string;
    created: number;
}
export interface DebugStep {
    stepNumber: number;
    action: 'examine' | 'test' | 'trace' | 'isolate' | 'verify';
    description: string;
    findings: string;
    nextAction?: string;
    confidence: number;
}
export interface ArchitectureAnalysis {
    id: string;
    context: string;
    requirements: string[];
    constraints: string[];
    designOptions: DesignOption[];
    recommendation: string;
    tradeoffs: string[];
    created: number;
}
export interface DesignOption {
    name: string;
    description: string;
    pros: string[];
    cons: string[];
    complexity: number;
    maintainability: number;
    performance: number;
    scalability: number;
}
export declare class CodingReasoningTool {
    private currentSession;
    private sessionFile;
    private currentProjectName;
    constructor();
    private getTempDir;
    /**
     * Execute a coding reasoning action
     */
    executeAction(action: CodingReasoningAction, args: any, projectName?: string): Promise<any>;
    /**
     * Analyze code using Chain-of-Thought reasoning
     */
    analyzeCode(code: string, language: string, context?: string, problem?: string): Promise<CodingReasoningResult>;
    /**
     * Step-by-step debugging using interactive reasoning
     */
    debugStepByStep(code: string, errorMessage: string, language: string, context?: string): Promise<DebugSession>;
    /**
     * Architecture reasoning for design decisions
     */
    architectureReasoning(context: string, requirements: string[], constraints: string[]): Promise<ArchitectureAnalysis>;
    /**
     * Performance analysis with reasoning
     */
    performanceAnalysis(code: string, language: string, context?: string): Promise<CodingReasoningResult>;
    /**
     * Refactoring planning with step-by-step reasoning
     */
    refactorPlanning(code: string, language: string, goals: string[], constraints?: string[]): Promise<CodingReasoningResult>;
    /**
     * Test strategy reasoning
     */
    testStrategy(code: string, language: string, requirements: string[]): Promise<CodingReasoningResult>;
    /**
     * Error investigation with detailed reasoning
     */
    errorInvestigation(errorMessage: string, code: string, language: string, context?: string): Promise<DebugSession>;
    /**
     * Code review with reasoning
     */
    codeReview(code: string, language: string, standards?: string[], context?: string): Promise<CodingReasoningResult>;
    private analyzeCodeStructure;
    private analyzeLogicFlow;
    private generateSolutions;
    private generateTestCases;
    private generatePerformanceNotes;
    private generateSecurityNotes;
    private analyzeErrorMessage;
    private traceCodeExecution;
    private isolateProblem;
    private generateDebugHypothesis;
    private testSolutions;
    private generateDebugSolution;
    private generateDesignOptions;
    private selectBestDesign;
    private analyzeTradeoffs;
    private estimateComplexity;
    private calculateControlFlowComplexity;
    private calculateOverallConfidence;
    private identifyErrorType;
    private getCommonCauses;
    private getLanguageSpecificNotes;
    private extractErrorLine;
    private traceExecutionPath;
    private identifyVariablesInScope;
    private identifyProblematicSection;
    private identifyDependencies;
    private describeIsolatedIssue;
    private generateSolutionForHypothesis;
    private evaluateSolution;
    private selectBestHypothesis;
    private generateBasicSolution;
    private generateOptimizedSolution;
    private generateMaintainableSolution;
    private generateSessionId;
    private ensureTempDir;
    private saveSession;
    cleanup(): Promise<void>;
    getStatus(): Promise<{
        active: boolean;
        session: string | null;
        file: string | null;
    }>;
}
//# sourceMappingURL=reasoning-tool.d.ts.map