dartmind 17.0.0

package/dist/v10/brain/Brain.js

@@ -0,0 +1,725 @@
+/**
+ * FlutterAI v10 - Brain
+ *
+ * The reasoning/planning core - separate from output formatting.
+ *
+ * Responsibilities:
+ * - Process requests and generate thoughts/reasoning
+ * - Create action plans
+ * - Track reasoning history
+ * - Support different thinking modes (fast/deep/balanced)
+ * - Handle context and state
+ * - Make decisions
+ * - Chain-of-thought reasoning (v10 Enhanced)
+ * - Structured step-by-step analysis (v10 Enhanced)
+ *
+ * @module v10/brain/Brain
+ */
+import { nanoid } from 'nanoid';
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    maxThoughts: 100,
+    maxPlanSteps: 10,
+    reasoningMode: 'balanced',
+    enableTracing: false
+};
+// ============================================================================
+// Brain Implementation
+// ============================================================================
+export class Brain {
+    config;
+    thoughts = [];
+    plans = [];
+    decisions = [];
+    sessionContext = {};
+    trace = [];
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    // --------------------------------------------------------------------------
+    // Config Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // --------------------------------------------------------------------------
+    // Thinking Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Generate a thought from a request
+     */
+    async think(request, options = {}) {
+        const startTime = new Date();
+        const reasoningMode = options.reasoningMode || this.config.reasoningMode;
+        const type = this.classifyThoughtType(request);
+        const confidence = this.calculateConfidence(request, type);
+        // Merge session context with provided context
+        const context = {
+            ...this.sessionContext,
+            ...options.context
+        };
+        const thought = {
+            id: nanoid(),
+            content: this.processThought(request, reasoningMode),
+            type,
+            timestamp: new Date(),
+            confidence,
+            reasoningMode,
+            parentId: options.parentId,
+            context: Object.keys(context).length > 0 ? context : undefined
+        };
+        // Add to history (respecting limit)
+        this.thoughts.push(thought);
+        if (this.thoughts.length > this.config.maxThoughts) {
+            this.thoughts.shift();
+        }
+        // Trace if enabled
+        if (this.config.enableTracing) {
+            const endTime = new Date();
+            this.trace.push({
+                type: 'think',
+                description: `Generated ${type} thought`,
+                startTime,
+                endTime,
+                duration: endTime.getTime() - startTime.getTime(),
+                data: { thoughtId: thought.id }
+            });
+        }
+        return thought;
+    }
+    /**
+     * Get all thoughts
+     */
+    getThoughts() {
+        return [...this.thoughts];
+    }
+    // --------------------------------------------------------------------------
+    // v10 Enhanced: Chain-of-Thought Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Deep thinking with chain-of-thought reasoning
+     * Generates multi-step reasoning for complex requests
+     */
+    async thinkDeep(request, options = {}) {
+        const startTime = Date.now();
+        const maxSteps = options.maxSteps || 5;
+        const reasoningMode = options.reasoningMode || 'deep';
+        // Generate reasoning steps
+        const reasoningSteps = this.generateReasoningSteps(request, maxSteps);
+        // Calculate overall confidence from steps
+        const overallConfidence = reasoningSteps.length > 0
+            ? reasoningSteps.reduce((sum, step) => sum + step.confidence, 0) / reasoningSteps.length
+            : 0.5;
+        // Synthesize final thought from reasoning steps
+        const synthesizedContent = this.synthesizeFromSteps(request, reasoningSteps);
+        // Create base thought
+        const thought = await this.think(request, {
+            ...options,
+            reasoningMode
+        });
+        // Extend with chain-of-thought data
+        const extendedThought = {
+            ...thought,
+            content: synthesizedContent,
+            confidence: overallConfidence,
+            reasoningSteps,
+            reasoningTime: Date.now() - startTime
+        };
+        // Add structured analysis if requested
+        if (options.structured) {
+            extendedThought.structuredAnalysis = this.generateStructuredAnalysis(request, reasoningSteps);
+        }
+        // Trace if enabled
+        if (this.config.enableTracing) {
+            this.trace.push({
+                type: 'think',
+                description: `Deep thinking with ${reasoningSteps.length} steps`,
+                startTime: new Date(startTime),
+                endTime: new Date(),
+                duration: Date.now() - startTime,
+                data: { thoughtId: extendedThought.id, steps: reasoningSteps.length }
+            });
+        }
+        return extendedThought;
+    }
+    /**
+     * Perform structured analysis of a request
+     * Returns organized findings, issues, and recommendations
+     */
+    async analyze(request, options = {}) {
+        // Use deep thinking to gather reasoning
+        const thought = await this.thinkDeep(request, {
+            ...options,
+            structured: true,
+            reasoningMode: 'deep'
+        });
+        return thought.structuredAnalysis || this.generateStructuredAnalysis(request, []);
+    }
+    /**
+     * Generate reasoning steps for chain-of-thought
+     */
+    generateReasoningSteps(request, maxSteps) {
+        const steps = [];
+        const lower = request.toLowerCase();
+        // Step 1: Understanding - What is being asked?
+        steps.push({
+            step: 1,
+            description: 'Understanding the request',
+            reasoning: `Analyzing the request: "${request.slice(0, 100)}${request.length > 100 ? '...' : ''}"`,
+            confidence: 0.9,
+            observations: this.extractObservations(request, 'understanding'),
+            conclusions: [`Request type: ${this.classifyThoughtType(request)}`]
+        });
+        // Step 2: Context gathering
+        if (steps.length < maxSteps) {
+            steps.push({
+                step: 2,
+                description: 'Gathering context',
+                reasoning: 'Identifying relevant context and constraints',
+                confidence: 0.85,
+                observations: this.extractObservations(request, 'context'),
+                conclusions: this.extractContextConclusions(request)
+            });
+        }
+        // Step 3: Analysis - What are the key components?
+        if (steps.length < maxSteps) {
+            const components = this.identifyComponents(request);
+            steps.push({
+                step: 3,
+                description: 'Identifying key components',
+                reasoning: `Breaking down the request into ${components.length} components`,
+                confidence: 0.8,
+                observations: components,
+                conclusions: [`${components.length} component(s) identified for processing`]
+            });
+        }
+        // Step 4: Planning - What approach should we take?
+        if (steps.length < maxSteps && (lower.includes('how') || lower.includes('fix') || lower.includes('implement'))) {
+            steps.push({
+                step: 4,
+                description: 'Planning approach',
+                reasoning: 'Determining the best approach based on analysis',
+                confidence: 0.75,
+                observations: ['Evaluated multiple approaches', 'Considered constraints'],
+                conclusions: this.generateApproachConclusions(request)
+            });
+        }
+        // Step 5: Synthesis - What is the final answer?
+        if (steps.length < maxSteps) {
+            steps.push({
+                step: steps.length + 1,
+                description: 'Synthesizing conclusion',
+                reasoning: 'Combining insights from previous steps',
+                confidence: 0.85,
+                observations: ['Reviewed all previous steps'],
+                conclusions: ['Ready to provide comprehensive response']
+            });
+        }
+        return steps;
+    }
+    /**
+     * Synthesize a final thought content from reasoning steps
+     */
+    synthesizeFromSteps(request, steps) {
+        if (steps.length === 0) {
+            return `Analysis: ${request}`;
+        }
+        const allConclusions = steps.flatMap(s => s.conclusions);
+        const keyObservations = steps
+            .slice(0, 3)
+            .flatMap(s => s.observations)
+            .slice(0, 5);
+        return `Deep analysis of: ${request}\n\n` +
+            `Key observations:\n${keyObservations.map(o => `- ${o}`).join('\n')}\n\n` +
+            `Conclusions:\n${allConclusions.map(c => `- ${c}`).join('\n')}`;
+    }
+    /**
+     * Generate structured analysis from reasoning steps
+     */
+    generateStructuredAnalysis(request, steps) {
+        const lower = request.toLowerCase();
+        const findings = [];
+        const issues = [];
+        const recommendations = [];
+        const risks = [];
+        // Extract from reasoning steps
+        for (const step of steps) {
+            findings.push(...step.observations.slice(0, 2));
+            if (step.conclusions.some(c => c.toLowerCase().includes('issue') || c.toLowerCase().includes('problem'))) {
+                issues.push(...step.conclusions);
+            }
+        }
+        // Generate recommendations based on request type
+        if (lower.includes('fix') || lower.includes('bug')) {
+            recommendations.push('Review error logs for root cause');
+            recommendations.push('Add tests to prevent regression');
+            risks.push('Fix may have side effects on related functionality');
+        }
+        if (lower.includes('refactor')) {
+            recommendations.push('Create backup before major changes');
+            recommendations.push('Refactor in small, testable increments');
+            risks.push('Refactoring may introduce subtle bugs');
+        }
+        if (lower.includes('performance') || lower.includes('optimize')) {
+            recommendations.push('Profile before optimizing');
+            recommendations.push('Measure improvement with benchmarks');
+            risks.push('Premature optimization may reduce code clarity');
+        }
+        // Default recommendations if none generated
+        if (recommendations.length === 0) {
+            recommendations.push('Review changes carefully before applying');
+            recommendations.push('Test in development environment first');
+        }
+        // Calculate overall confidence
+        const confidence = steps.length > 0
+            ? steps.reduce((sum, s) => sum + s.confidence, 0) / steps.length
+            : 0.7;
+        return {
+            summary: `Analysis of: ${request.slice(0, 100)}${request.length > 100 ? '...' : ''}`,
+            findings: findings.slice(0, 5),
+            issues: issues.slice(0, 3),
+            recommendations: recommendations.slice(0, 5),
+            risks: risks.slice(0, 3),
+            confidence
+        };
+    }
+    /**
+     * Extract observations based on analysis type
+     */
+    extractObservations(request, type) {
+        const observations = [];
+        const lower = request.toLowerCase();
+        if (type === 'understanding') {
+            if (lower.includes('?'))
+                observations.push('Request is a question');
+            if (lower.includes('fix') || lower.includes('bug'))
+                observations.push('Request involves fixing an issue');
+            if (lower.includes('add') || lower.includes('create'))
+                observations.push('Request involves creating something new');
+            if (lower.includes('refactor'))
+                observations.push('Request involves restructuring code');
+            if (lower.includes('test'))
+                observations.push('Request involves testing');
+            if (lower.includes('explain') || lower.includes('what'))
+                observations.push('Request seeks explanation');
+        }
+        else if (type === 'context') {
+            if (lower.includes('flutter') || lower.includes('dart'))
+                observations.push('Context: Flutter/Dart development');
+            if (lower.includes('widget'))
+                observations.push('Context: Widget development');
+            if (lower.includes('state'))
+                observations.push('Context: State management');
+            if (lower.includes('api') || lower.includes('http'))
+                observations.push('Context: API/networking');
+            if (lower.includes('ui') || lower.includes('design'))
+                observations.push('Context: UI/design');
+        }
+        return observations.length > 0 ? observations : ['General request analyzed'];
+    }
+    /**
+     * Extract context conclusions
+     */
+    extractContextConclusions(request) {
+        const conclusions = [];
+        const lower = request.toLowerCase();
+        if (lower.includes('error') || lower.includes('exception')) {
+            conclusions.push('Error handling context detected');
+        }
+        if (lower.includes('slow') || lower.includes('performance')) {
+            conclusions.push('Performance optimization context detected');
+        }
+        if (lower.includes('secure') || lower.includes('auth')) {
+            conclusions.push('Security context detected');
+        }
+        if (lower.includes('test') || lower.includes('coverage')) {
+            conclusions.push('Testing context detected');
+        }
+        return conclusions.length > 0 ? conclusions : ['Standard development context'];
+    }
+    /**
+     * Identify components in the request
+     */
+    identifyComponents(request) {
+        const components = [];
+        const lower = request.toLowerCase();
+        // File references
+        const fileMatch = request.match(/[\w-]+\.(dart|ts|js|json|yaml)/g);
+        if (fileMatch) {
+            components.push(...fileMatch.map(f => `File: ${f}`));
+        }
+        // Function/method references
+        if (lower.includes('function') || lower.includes('method')) {
+            components.push('Function/method modification');
+        }
+        // Widget references
+        if (lower.includes('widget')) {
+            components.push('Widget component');
+        }
+        // State references
+        if (lower.includes('state') || lower.includes('provider') || lower.includes('bloc')) {
+            components.push('State management');
+        }
+        return components.length > 0 ? components : ['Request component'];
+    }
+    /**
+     * Generate approach conclusions
+     */
+    generateApproachConclusions(request) {
+        const conclusions = [];
+        const lower = request.toLowerCase();
+        if (lower.includes('fix')) {
+            conclusions.push('Approach: Diagnose → Fix → Verify');
+        }
+        else if (lower.includes('refactor')) {
+            conclusions.push('Approach: Analyze → Extract → Restructure → Test');
+        }
+        else if (lower.includes('add') || lower.includes('implement')) {
+            conclusions.push('Approach: Design → Implement → Integrate → Test');
+        }
+        else if (lower.includes('optimize')) {
+            conclusions.push('Approach: Profile → Identify bottlenecks → Optimize → Benchmark');
+        }
+        else {
+            conclusions.push('Approach: Analyze → Plan → Execute → Verify');
+        }
+        return conclusions;
+    }
+    // --------------------------------------------------------------------------
+    // Planning Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Create an action plan
+     */
+    async plan(request, options = {}) {
+        const startTime = new Date();
+        const steps = this.generateSteps(request);
+        const plan = {
+            id: nanoid(),
+            steps: steps.slice(0, this.config.maxPlanSteps),
+            status: 'pending',
+            createdAt: new Date(),
+            sourceThoughtId: options.sourceThoughtId
+        };
+        this.plans.push(plan);
+        // Trace if enabled
+        if (this.config.enableTracing) {
+            const endTime = new Date();
+            this.trace.push({
+                type: 'plan',
+                description: `Created plan with ${plan.steps.length} steps`,
+                startTime,
+                endTime,
+                duration: endTime.getTime() - startTime.getTime(),
+                data: { planId: plan.id }
+            });
+        }
+        return plan;
+    }
+    /**
+     * Get all plans
+     */
+    getPlans() {
+        return [...this.plans];
+    }
+    // --------------------------------------------------------------------------
+    // Decision Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Make a decision
+     */
+    async decide(question, options = {}) {
+        const startTime = new Date();
+        const decision = {
+            id: nanoid(),
+            question,
+            reasoning: this.generateReasoning(question, options.choices),
+            confidence: this.calculateDecisionConfidence(question, options.choices),
+            timestamp: new Date()
+        };
+        // Set answer based on whether choices were provided
+        if (options.choices && options.choices.length > 0) {
+            decision.choice = this.selectChoice(question, options.choices);
+        }
+        else {
+            decision.answer = this.makeBinaryDecision(question);
+        }
+        this.decisions.push(decision);
+        // Trace if enabled
+        if (this.config.enableTracing) {
+            const endTime = new Date();
+            this.trace.push({
+                type: 'decide',
+                description: `Made decision: ${decision.answer !== undefined ? decision.answer : decision.choice}`,
+                startTime,
+                endTime,
+                duration: endTime.getTime() - startTime.getTime(),
+                data: { decisionId: decision.id }
+            });
+        }
+        return decision;
+    }
+    /**
+     * Get all decisions
+     */
+    getDecisions() {
+        return [...this.decisions];
+    }
+    // --------------------------------------------------------------------------
+    // Context Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Set session context value
+     */
+    setContext(key, value) {
+        this.sessionContext[key] = value;
+        if (this.config.enableTracing) {
+            this.trace.push({
+                type: 'context',
+                description: `Set context: ${key}`,
+                startTime: new Date(),
+                endTime: new Date(),
+                duration: 0,
+                data: { key, value }
+            });
+        }
+    }
+    /**
+     * Get session context value
+     */
+    getContext(key) {
+        return this.sessionContext[key];
+    }
+    /**
+     * Clear all session context
+     */
+    clearContext() {
+        this.sessionContext = {};
+    }
+    // --------------------------------------------------------------------------
+    // Tracing Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Check if tracing is enabled
+     */
+    isTracingEnabled() {
+        return this.config.enableTracing;
+    }
+    /**
+     * Get trace events
+     */
+    getTrace() {
+        return [...this.trace];
+    }
+    /**
+     * Clear trace history
+     */
+    clearTrace() {
+        this.trace = [];
+    }
+    // --------------------------------------------------------------------------
+    // State Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Export current state
+     */
+    exportState() {
+        return {
+            thoughts: [...this.thoughts],
+            plans: [...this.plans],
+            decisions: [...this.decisions],
+            context: { ...this.sessionContext }
+        };
+    }
+    /**
+     * Import state snapshot
+     */
+    importState(state) {
+        this.thoughts = [...state.thoughts];
+        this.plans = [...state.plans];
+        this.decisions = [...state.decisions];
+        this.sessionContext = { ...state.context };
+    }
+    /**
+     * Reset to initial state
+     */
+    reset() {
+        this.thoughts = [];
+        this.plans = [];
+        this.decisions = [];
+        this.sessionContext = {};
+        this.trace = [];
+    }
+    // --------------------------------------------------------------------------
+    // Private Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Classify the type of thought based on request
+     */
+    classifyThoughtType(request) {
+        const lower = request.toLowerCase();
+        if (lower.includes('what') || lower.includes('why') || lower.includes('analyze') || lower.includes('wrong')) {
+            return 'analysis';
+        }
+        if (lower.includes('how') || lower.includes('should') || lower.includes('plan') || lower.includes('approach')) {
+            return 'planning';
+        }
+        if (lower.includes('apply') || lower.includes('fix') || lower.includes('update') || lower.includes('change') || lower.includes('edit')) {
+            return 'action';
+        }
+        if (lower.includes('see') || lower.includes('notice') || lower.includes('found') || lower.includes('observe')) {
+            return 'observation';
+        }
+        if (lower.includes('think') || lower.includes('consider') || lower.includes('reflect')) {
+            return 'reflection';
+        }
+        return 'analysis'; // Default
+    }
+    /**
+     * Process thought content based on reasoning mode
+     */
+    processThought(request, mode) {
+        // In a real implementation, this would involve more sophisticated reasoning
+        // For now, we return the request with mode-appropriate framing
+        switch (mode) {
+            case 'fast':
+                return `Quick analysis: ${request}`;
+            case 'deep':
+                return `Deep consideration: ${request}. Multiple perspectives evaluated.`;
+            case 'balanced':
+            default:
+                return `Analysis: ${request}`;
+        }
+    }
+    /**
+     * Calculate confidence based on request specificity
+     */
+    calculateConfidence(request, type) {
+        let confidence = 0.5; // Base confidence
+        // More specific requests get higher confidence
+        if (request.includes('line'))
+            confidence += 0.2;
+        if (request.includes('function') || request.includes('method'))
+            confidence += 0.15;
+        if (request.includes('file') || request.match(/\.\w{2,4}$/))
+            confidence += 0.1;
+        // Action thoughts tend to have higher confidence
+        if (type === 'action')
+            confidence += 0.1;
+        return Math.min(confidence, 1);
+    }
+    /**
+     * Generate plan steps from request
+     */
+    generateSteps(request) {
+        const steps = [];
+        const lower = request.toLowerCase();
+        // Analyze step (almost always needed)
+        steps.push({
+            order: 1,
+            description: 'Analyze current state and requirements',
+            complexity: 'low',
+            tools: ['read', 'grep']
+        });
+        // Planning step
+        steps.push({
+            order: 2,
+            description: 'Plan the changes needed',
+            complexity: 'low',
+            tools: []
+        });
+        // Main action step
+        if (lower.includes('edit') || lower.includes('fix') || lower.includes('update') || lower.includes('change')) {
+            steps.push({
+                order: 3,
+                description: 'Apply the changes',
+                complexity: 'medium',
+                tools: ['edit']
+            });
+        }
+        if (lower.includes('refactor')) {
+            steps.push({
+                order: 3,
+                description: 'Refactor the code structure',
+                complexity: 'high',
+                tools: ['read', 'edit', 'write']
+            });
+        }
+        if (lower.includes('test')) {
+            steps.push({
+                order: steps.length + 1,
+                description: 'Run tests to verify changes',
+                complexity: 'low',
+                tools: ['bash']
+            });
+        }
+        // Verification step
+        steps.push({
+            order: steps.length + 1,
+            description: 'Verify the result',
+            complexity: 'low',
+            tools: ['read']
+        });
+        // Re-number steps
+        return steps.map((step, index) => ({
+            ...step,
+            order: index + 1
+        }));
+    }
+    /**
+     * Generate reasoning for a decision
+     */
+    generateReasoning(question, choices) {
+        if (choices) {
+            return `Evaluated ${choices.length} options for: "${question}"`;
+        }
+        return `Considered factors for: "${question}"`;
+    }
+    /**
+     * Calculate decision confidence
+     */
+    calculateDecisionConfidence(question, choices) {
+        let confidence = 0.6;
+        // Clear questions get higher confidence
+        if (question.includes('?'))
+            confidence += 0.1;
+        if (question.length < 50)
+            confidence += 0.1;
+        // Multiple choices slightly reduce confidence
+        if (choices && choices.length > 3)
+            confidence -= 0.1;
+        return Math.max(0, Math.min(confidence, 1));
+    }
+    /**
+     * Select from available choices
+     */
+    selectChoice(question, choices) {
+        // Simple heuristic: prefer first option (often recommended)
+        // In real implementation, this would be more sophisticated
+        return choices[0];
+    }
+    /**
+     * Make a binary yes/no decision
+     */
+    makeBinaryDecision(question) {
+        const lower = question.toLowerCase();
+        // Heuristics for common patterns
+        if (lower.includes('safe') || lower.includes('should')) {
+            return true; // Default to safe/recommended
+        }
+        if (lower.includes('danger') || lower.includes('risky')) {
+            return false;
+        }
+        return true; // Default to yes
+    }
+}
+// ============================================================================
+// Export
+// ============================================================================
+export default Brain;
+//# sourceMappingURL=Brain.js.map