@sschepis/robodev 1.0.0

package/src/quality/code-validator.mjs

@@ -0,0 +1,126 @@
+// Code Validator
+// Performs real-time validation (linting, type-checking) on files
+// to provide immediate feedback to AI agents.
+
+import { exec } from 'child_process';
+import util from 'util';
+import path from 'path';
+import fs from 'fs';
+import { consoleStyler } from '../ui/console-styler.mjs';
+
+const execPromise = util.promisify(exec);
+
+export class CodeValidator {
+    constructor(workingDir) {
+        this.workingDir = workingDir;
+    }
+
+    /**
+     * Validates a file based on its extension.
+     * @param {string} filePath - Relative path to the file
+     * @returns {Promise<string|null>} - Formatted error string or null if valid
+     */
+    async validateFile(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const fullPath = path.resolve(this.workingDir, filePath);
+        
+        // Only validate if file exists
+        if (!fs.existsSync(fullPath)) {
+            return null;
+        }
+
+        try {
+            if (['.ts', '.tsx'].includes(ext)) {
+                return await this.validateTypeScript(filePath);
+            } else if (['.js', '.mjs', '.jsx'].includes(ext)) {
+                return await this.validateJavaScript(filePath);
+            }
+        } catch (error) {
+            // If validation command fails (e.g. tsc not found), log it but don't break the tool
+            consoleStyler.log('error', `Validation tool error: ${error.message}`);
+            return `(Validation tool failed: ${error.message})`; 
+        }
+
+        return null;
+    }
+
+    async validateTypeScript(filePath) {
+        // Run tsc on the specific file
+        // --noEmit: Don't generate JS
+        // --skipLibCheck: Speed up
+        // --allowJs: Allow JS files in check if needed
+        // --pretty false: output parseable text
+        // We use npx to use local or cached tsc
+        // Increased resilience with project root finding logic could go here, 
+        // but cwd execution is usually sufficient for relative paths.
+        
+        const cmd = `npx tsc --noEmit --skipLibCheck --allowJs --target es2020 --moduleResolution node --pretty false "${filePath}"`;
+        
+        try {
+            await execPromise(cmd, { cwd: this.workingDir, timeout: 30000 }); // 30s timeout
+            return null; // Success = no output/errors
+        } catch (error) {
+            // timeout error
+            if (error.signal === 'SIGTERM') {
+                return `Validation timed out after 30s for ${filePath}`;
+            }
+
+            // tsc exits with non-zero if errors found
+            // stdout contains the errors
+            const output = error.stdout || error.stderr;
+            return this.formatOutput(output, filePath);
+        }
+    }
+
+    async validateJavaScript(filePath) {
+        // Try ESLint first
+        try {
+            const eslintCmd = `npx eslint --no-color --format unix "${filePath}"`;
+            await execPromise(eslintCmd, { cwd: this.workingDir, timeout: 20000 });
+            return null;
+        } catch (error) {
+            // If eslint fails due to config missing or errors found
+            if (error.stdout && (error.stdout.includes(filePath) || error.stdout.includes('error'))) {
+                 return this.formatOutput(error.stdout, filePath);
+            }
+            
+            // Fallback: Syntax check with node
+            try {
+                // node -c checks syntax
+                const nodeCmd = `node --check "${filePath}"`;
+                await execPromise(nodeCmd, { cwd: this.workingDir, timeout: 10000 });
+                return null;
+            } catch (syntaxError) {
+                return `Syntax Error: ${syntaxError.stderr.trim()}`;
+            }
+        }
+    }
+
+    formatOutput(output, filePath) {
+        if (!output) return null;
+
+        // Clean up ANSI codes if any remain (though we try to suppress them)
+        const cleanOutput = output.replace(/\u001b\[[0-9;]*m/g, '');
+
+        const lines = cleanOutput.split('\n');
+        
+        // Filter lines relevant to the file or generic errors
+        // We want to capture the specific error lines, usually formatted like "file.ts(1,1): error ..."
+        const fileName = path.basename(filePath);
+        const relevantLines = lines.filter(line => 
+            line.includes(fileName) || 
+            line.includes('error TS') || 
+            (line.includes('Error:') && !line.includes('Validation tool error'))
+        );
+        
+        if (relevantLines.length === 0) return null;
+
+        // Limit output size to prevent context flooding
+        const MAX_LINES = 15;
+        if (relevantLines.length > MAX_LINES) {
+            return relevantLines.slice(0, MAX_LINES).join('\n') + `\n... (${relevantLines.length - MAX_LINES} more errors truncated)`;
+        }
+
+        return relevantLines.join('\n');
+    }
+}

package/src/quality/quality-evaluator.mjs

@@ -0,0 +1,248 @@
+// Quality evaluation system
+// Handles response quality evaluation and retry logic
+
+import { consoleStyler } from '../ui/console-styler.mjs';
+import { ENHANCEMENT_TOOLS } from '../tools/tool-definitions.mjs';
+import { callProvider } from '../core/ai-provider.mjs';
+
+export class QualityEvaluator {
+    constructor(endpoint) {
+        this.endpoint = endpoint; // kept for backward compatibility
+        this.qualityIssue = null;
+        this.retryAttempts = 0;
+        this.maxRetryAttempts = 2;
+    }
+
+    // Evaluate response quality using AI
+    async evaluateResponse(userInput, finalResponse, toolCallsSummary, toolResults, createSystemPrompt, workingDir, workspace) {
+        // Don't evaluate if we've already exceeded retry attempts
+        if (this.retryAttempts >= this.maxRetryAttempts) {
+            consoleStyler.log('quality', `Skipping quality evaluation - max retry attempts (${this.maxRetryAttempts}) reached`);
+            return null;
+        }
+
+        consoleStyler.log('quality', 'Preparing comprehensive quality evaluation context...');
+
+        // Create comprehensive context for quality evaluation
+        let evaluationContext = `Please evaluate the quality of this AI response using the evaluate_response_quality tool:
+
+ORIGINAL QUERY: "${userInput}"
+
+AI RESPONSE: "${finalResponse}"`;
+
+        if (toolCallsSummary.length > 0) {
+            evaluationContext += `
+
+TOOLS USED BY AI:`;
+            toolCallsSummary.forEach((call, i) => {
+                evaluationContext += `
+${i + 1}. ${call.tool}(${Object.entries(call.parameters).map(([k,v]) => `${k}: ${JSON.stringify(v)}`).join(', ')})`;
+            });
+
+            if (toolResults.length > 0) {
+                evaluationContext += `
+
+TOOL RESULTS:`;
+                toolResults.forEach((result, i) => {
+                    let resultStr = typeof result.result === 'string' ? result.result : JSON.stringify(result.result);
+                    if (resultStr === undefined) resultStr = 'undefined';
+                    evaluationContext += `
+${i + 1}. ${result.tool}: ${resultStr.substring(0, 200)}${resultStr.length > 200 ? '...' : ''}`;
+                });
+            }
+        }
+
+        evaluationContext += `
+
+EVALUATION CRITERIA:
+- 10 = Perfect response that fully addresses the query (consider both text response AND tool usage)
+- 7-9 = Good response with minor issues
+- 4-6 = Adequate but could be improved
+- 1-3 = Poor response that doesn't address the query properly
+
+IMPORTANT: When evaluating, consider BOTH the text response AND the tools that were called. If the user asked for something to be done and the AI called the appropriate tools successfully, that should be reflected in the quality score even if the text response is brief.
+
+If rating < 4, provide specific remedy suggestions.`;
+
+        // Create a quality evaluation request
+        const qualityCheckHistory = [
+            { role: 'system', content: createSystemPrompt(workingDir, workspace) },
+            {
+                role: 'user',
+                content: evaluationContext
+            }
+        ];
+
+        consoleStyler.log('quality', `Evaluating response quality with ${toolCallsSummary.length} tool calls and ${toolResults.length} tool results`);
+        
+        try {
+            // Import config dynamically to avoid circular dependencies
+            const { config } = await import('../config.mjs');
+            
+            const qualityResult = await callProvider({
+                model: config.ai.model,
+                messages: qualityCheckHistory,
+                tools: ENHANCEMENT_TOOLS,
+                tool_choice: { type: "function", function: { name: "evaluate_response_quality" } },
+                temperature: 0.1,
+                reasoning_effort: "high"  // Quality evaluation always uses high reasoning
+            });
+
+            if (qualityResult && qualityResult.choices) {
+                const qualityMessage = qualityResult.choices[0].message;
+                
+                if (qualityMessage.tool_calls && qualityMessage.tool_calls.length > 0) {
+                    for (const toolCall of qualityMessage.tool_calls) {
+                        if (toolCall.function.name === 'evaluate_response_quality') {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            const { quality_rating = 0, evaluation_reasoning = "No reasoning provided", remedy_suggestion = "" } = args;
+                            
+                            consoleStyler.log('quality', `Quality evaluation results:`);
+                            consoleStyler.log('quality', `   Rating: ${quality_rating}/10`, { indent: true });
+                            if (evaluation_reasoning && typeof evaluation_reasoning === 'string') {
+                                consoleStyler.log('quality', `   Reasoning: ${evaluation_reasoning.substring(0, 100)}...`, { indent: true });
+                            }
+                            if (remedy_suggestion && typeof remedy_suggestion === 'string') {
+                                consoleStyler.log('quality', `   Remedy: ${remedy_suggestion.substring(0, 100)}...`, { indent: true });
+                            }
+                            
+                            return {
+                                rating: quality_rating,
+                                reasoning: evaluation_reasoning,
+                                remedy: remedy_suggestion,
+                                needsRetry: quality_rating < 4 && remedy_suggestion
+                            };
+                        }
+                    }
+                }
+            }
+        } catch (qualityError) {
+            consoleStyler.log('error', `Quality evaluation failed: ${qualityError.message}`, { box: true });
+        }
+
+        consoleStyler.log('quality', 'Quality evaluation completed with no actionable results');
+        return null;
+    }
+
+    // Check if retry is needed based on quality evaluation
+    shouldRetry(qualityResult) {
+        if (!qualityResult || !qualityResult.needsRetry) {
+            return false;
+        }
+
+        if (this.retryAttempts >= this.maxRetryAttempts) {
+            consoleStyler.log('quality', `Maximum retry attempts (${this.maxRetryAttempts}) reached`);
+            return false;
+        }
+
+        return true;
+    }
+
+    // Create improved prompt for retry
+    createRetryPrompt(userInput, finalResponse, qualityResult) {
+        this.retryAttempts++;
+        
+        consoleStyler.log('quality', `Poor quality detected (${qualityResult.rating}/10)`, { box: true });
+        consoleStyler.log('quality', `Remedy: ${qualityResult.remedy}`);
+        
+        // Store quality issue for reference
+        this.qualityIssue = {
+            rating: qualityResult.rating,
+            reasoning: qualityResult.reasoning,
+            remedy: qualityResult.remedy,
+            original_query: userInput,
+            poor_response: finalResponse
+        };
+        
+        // Create improved prompt with remedy
+        const improvedPrompt = `${userInput}
+
+PREVIOUS RESPONSE WAS INADEQUATE (rated ${qualityResult.rating}/10):
+"${finalResponse}"
+
+REMEDY REQUIRED: ${qualityResult.remedy}
+
+Please provide a better response that addresses these quality issues.`;
+        
+        return improvedPrompt;
+    }
+
+    // Reset quality evaluation state
+    reset() {
+        this.qualityIssue = null;
+        this.retryAttempts = 0;
+    }
+
+    // Get current quality issue
+    getQualityIssue() {
+        return this.qualityIssue;
+    }
+
+    // Get retry attempt count
+    getRetryAttempts() {
+        return this.retryAttempts;
+    }
+
+    // Set quality issue manually (for tool execution)
+    setQualityIssue(issue) {
+        this.qualityIssue = issue;
+    }
+
+    // Check if we're currently in a retry situation
+    isRetrying() {
+        return this.retryAttempts > 0;
+    }
+
+    // Get quality evaluation summary for logging
+    getQualitySummary() {
+        if (!this.qualityIssue) {
+            return "No quality issues detected";
+        }
+        
+        return `Quality issue: ${this.qualityIssue.rating}/10 - ${this.qualityIssue.remedy}`;
+    }
+
+    // Handle quality evaluation result from tool execution
+    handleQualityToolResult(args) {
+        const { quality_rating = 0, evaluation_reasoning = "No reasoning", remedy_suggestion = "" } = args;
+        
+        if (quality_rating < 4) {
+            console.log(`\x1b[31m[QUALITY] Poor quality detected (${quality_rating}/10)\x1b[0m`);
+            if (remedy_suggestion) {
+                console.log(`\x1b[33m[QUALITY] Remedy: ${remedy_suggestion}\x1b[0m`);
+            }
+            
+            // Store quality issue for retry
+            this.qualityIssue = {
+                rating: quality_rating,
+                reasoning: evaluation_reasoning,
+                remedy: remedy_suggestion
+            };
+            
+            return `Quality rating ${quality_rating}/10 - retry needed with remedy: ${remedy_suggestion}`;
+        } else {
+            return `Quality rating ${quality_rating}/10 - response approved`;
+        }
+    }
+
+    // Extract tool call summary for quality evaluation
+    extractToolCallsSummary(history) {
+        return history
+            .filter(msg => msg.tool_calls && msg.tool_calls.length > 0)
+            .map(msg => msg.tool_calls.map(call => ({
+                tool: call.function.name,
+                parameters: JSON.parse(call.function.arguments)
+            })))
+            .flat();
+    }
+
+    // Extract tool results for quality evaluation
+    extractToolResults(history) {
+        return history
+            .filter(msg => msg.role === 'tool')
+            .map(msg => ({
+                tool: msg.name,
+                result: msg.content
+            }));
+    }
+}

package/src/reasoning/reasoning-system.mjs

@@ -0,0 +1,258 @@
+// Reasoning system for determining appropriate effort levels
+// This module handles all logic related to determining how much reasoning effort to apply
+
+import { consoleStyler } from '../ui/console-styler.mjs';
+
+export class ReasoningSystem {
+    constructor() {
+        this.errorHistory = [];
+        this.predictedReasoning = null;
+        this.reasoningJustification = null;
+    }
+
+    // Determine reasoning effort based on task complexity
+    determineReasoningEffort(userInput, context = {}) {
+        // Check for user preference first
+        const userPreference = this.parseUserReasoningPreference(userInput);
+        if (userPreference) return userPreference;
+
+        // Check for complexity indicators
+        const complexityIndicators = {
+            high: [
+                /debug|troubleshoot|analyze error/i,
+                /architect|design|plan/i,
+                /optimize|refactor|improve performance/i,
+                /complex|complicated|multi-step/i,
+                /why|explain|understand/i,
+                /embellish|enhance|improve/i
+            ],
+            medium: [
+                /create|build|implement/i,
+                /fix|solve|resolve/i,
+                /convert|transform/i,
+                /test|validate/i,
+                /fetch|scrape|extract/i
+            ],
+            low: [
+                /simple|basic|quick/i,
+                /list|show|display/i,
+                /check|verify/i,
+                /format|clean/i,
+                /update status/i
+            ]
+        };
+        
+        // Check if we're in a recovery/retry situation
+        if (context.isRetry || context.errorCount > 0) {
+            consoleStyler.log('reasoning', 'Using high effort due to retry/error context');
+            return "high";
+        }
+        
+        // Check if we have a todo list with many steps
+        if (context.todoCount && context.todoCount > 5) {
+            consoleStyler.log('reasoning', 'Using high effort due to complex multi-step task');
+            return "high";
+        }
+        
+        // Pattern matching
+        for (const [level, patterns] of Object.entries(complexityIndicators)) {
+            if (patterns.some(pattern => pattern.test(userInput))) {
+                consoleStyler.log('reasoning', `Detected ${level} complexity from input patterns`);
+                return level;
+            }
+        }
+        
+        return "medium"; // Default
+    }
+
+    // Parse user preference for reasoning level
+    parseUserReasoningPreference(userInput) {
+        const reasoningHints = {
+            high: /\b(carefully|thoroughly|deeply|detailed|comprehensive)\b/i,
+            low: /\b(quickly|briefly|simple|fast|quick)\b/i
+        };
+        
+        for (const [level, pattern] of Object.entries(reasoningHints)) {
+            if (pattern.test(userInput)) {
+                consoleStyler.log('reasoning', `User requested ${level} effort`);
+                return level;
+            }
+        }
+        
+        return null; // No preference detected
+    }
+
+    // Get adaptive reasoning based on error history
+    getAdaptiveReasoningEffort() {
+        const recentErrors = this.errorHistory.filter(err => {
+            const errorTime = new Date(err.timestamp);
+            const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+            return errorTime > fiveMinutesAgo;
+        });
+        
+        if (recentErrors.length >= 3) {
+            consoleStyler.log('reasoning', `Using high effort due to ${recentErrors.length} recent errors`);
+            return "high";
+        }
+        if (recentErrors.length >= 1) {
+            consoleStyler.log('reasoning', 'Using medium effort due to recent errors');
+            return "medium";
+        }
+        return "low";
+    }
+
+    // Get tool-specific reasoning level
+    getToolSpecificReasoning(toolName) {
+        const toolReasoningMap = {
+            'analyze_and_recover': 'high',      // Error recovery needs deep thinking
+            'embellish_request': 'high',        // Planning needs thorough analysis
+            'execute_javascript': 'medium',      // Code execution is straightforward
+            'create_todo_list': 'high',         // Planning multi-step tasks
+            'update_todo_status': 'low',        // Simple status update
+            'evaluate_response_quality': 'high' // Quality evaluation needs careful analysis
+        };
+        
+        const level = toolReasoningMap[toolName] || 'medium';
+        consoleStyler.log('reasoning', `Using ${level} effort for tool: ${toolName}`);
+        return level;
+    }
+
+    // Get context-aware reasoning based on conversation state
+    getContextAwareReasoning(context = {}) {
+        const { historyLength = 0, toolCallCount = 0, pendingSteps = 0 } = context;
+        
+        // Long conversations might need more reasoning
+        if (historyLength > 20) {
+            consoleStyler.log('reasoning', 'Using high effort due to long conversation history');
+            return "high";
+        }
+        
+        // Multiple tool calls in history suggest complex task
+        if (toolCallCount > 5) {
+            consoleStyler.log('reasoning', 'Using high effort due to multiple tool calls');
+            return "high";
+        }
+        
+        // Check if we're in the middle of a multi-step process
+        if (pendingSteps > 3) {
+            consoleStyler.log('reasoning', `Using high effort due to ${pendingSteps} pending steps`);
+            return "high";
+        }
+        
+        return "medium";
+    }
+
+    // Combine all reasoning strategies to determine final effort level
+    determineOptimalReasoning(userInput = null, toolName = null, context = {}) {
+        // Priority order for reasoning determination
+        // 1. Tool-specific reasoning (if tool is being used)
+        if (toolName) {
+            return this.getToolSpecificReasoning(toolName);
+        }
+        
+        // 2. Error-based adaptive reasoning
+        const errorBasedReasoning = this.getAdaptiveReasoningEffort();
+        if (errorBasedReasoning === "high") {
+            return errorBasedReasoning;
+        }
+        
+        // 3. Context-aware reasoning
+        const contextReasoning = this.getContextAwareReasoning(context);
+        if (contextReasoning === "high") {
+            return contextReasoning;
+        }
+        
+        // 4. Task complexity reasoning
+        const complexityReasoning = this.determineReasoningEffort(userInput || '', {
+            isRetry: context.retryAttempts > 0,
+            errorCount: this.errorHistory.length,
+            todoCount: context.todoCount
+        });
+        
+        // Return the highest reasoning level among all strategies
+        const levels = [errorBasedReasoning, contextReasoning, complexityReasoning];
+        if (levels.includes("high")) return "high";
+        if (levels.includes("medium")) return "medium";
+        return "low";
+    }
+
+    // Add error to history for adaptive reasoning
+    addError(error) {
+        this.errorHistory.push({
+            error: error.message,
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    // Set predicted reasoning from embellishment
+    setPredictedReasoning(reasoning, justification) {
+        this.predictedReasoning = reasoning;
+        this.reasoningJustification = justification;
+        consoleStyler.log('reasoning', `Predicted: ${reasoning} - ${justification}`);
+    }
+
+    // Get predicted reasoning
+    getPredictedReasoning() {
+        return this.predictedReasoning;
+    }
+
+    // Get simplified reasoning with minimal logic for performance
+    getSimplifiedReasoning(userInput = '', context = {}) {
+        // Critical overrides only
+        const recentErrors = this.errorHistory.filter(err => {
+            const errorTime = new Date(err.timestamp);
+            const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+            return errorTime > fiveMinutesAgo;
+        }).length;
+        
+        if (recentErrors >= 2) {
+            consoleStyler.log('reasoning', `Override: high due to ${recentErrors} recent errors`);
+            return "high";
+        }
+        
+        if (context.toolName === 'analyze_and_recover' || context.toolName === 'evaluate_response_quality') {
+            consoleStyler.log('reasoning', `Override: high for ${context.toolName}`);
+            return "high";
+        }
+        
+        if (this.predictedReasoning) {
+            consoleStyler.log('reasoning', `Using predicted: ${this.predictedReasoning}`);
+            return this.predictedReasoning;
+        }
+        
+        // Default fallback
+        consoleStyler.log('reasoning', 'Using default: medium');
+        return "medium";
+    }
+
+    // Reset reasoning state
+    reset() {
+        this.predictedReasoning = null;
+        this.reasoningJustification = null;
+    }
+
+    // Simple heuristic-based reasoning prediction as fallback
+    predictReasoningFromInput(userInput) {
+        const lowerInput = userInput.toLowerCase();
+        
+        if (lowerInput.includes('quickly') || lowerInput.includes('quick') || 
+            lowerInput.includes('fast') || lowerInput.includes('briefly')) {
+            this.predictedReasoning = 'low';
+            consoleStyler.log('reasoning', 'Detected user preference: low (quick/fast)');
+        } else if (lowerInput.includes('thoroughly') || lowerInput.includes('detailed') ||
+                   lowerInput.includes('comprehensive') || lowerInput.includes('carefully')) {
+            this.predictedReasoning = 'high';
+            consoleStyler.log('reasoning', 'Detected user preference: high (thorough/detailed)');
+        } else if (lowerInput.includes('debug') || lowerInput.includes('analyze') ||
+                   lowerInput.includes('troubleshoot') || lowerInput.includes('complex')) {
+            this.predictedReasoning = 'high';
+            consoleStyler.log('reasoning', 'Detected complexity: high (debug/analyze)');
+        } else if (lowerInput.includes('simple') || lowerInput.includes('basic') ||
+                   lowerInput.includes('count') || lowerInput.includes('list')) {
+            this.predictedReasoning = 'low';
+            consoleStyler.log('reasoning', 'Detected simplicity: low (simple/basic)');
+        }
+        
+        return this.predictedReasoning;
+    }
+}