app.py

import os
import logging
from flask import Flask, request, jsonify, render_template
from dotenv import load_dotenv
from supplemental import EnhancedAIAgent, ProjectConfig

# Load environment variables
load_dotenv()

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Initialize Flask app
app = Flask(__name__)

# Initialize EnhancedAIAgent
agent = EnhancedAIAgent(
    name="WebDevMaster",
    description="Expert in full-stack web development",
    skills=["HTML", "CSS", "JavaScript", "React", "Node.js"],
    model_name="gpt2"
)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/generate_project_config', methods=['POST'])
def generate_project_config():
    try:
        project_description = request.json['project_description']
        config = agent.generate_project_config(project_description)
        return jsonify(config.__dict__), 200
    except Exception as e:
        logger.error(f"Error generating project config: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/create_project_structure', methods=['POST'])
def create_project_structure():
    try:
        config_dict = request.json
        config = ProjectConfig(**config_dict)
        structure = agent.create_project_structure(config)
        return jsonify(structure), 200
    except Exception as e:
        logger.error(f"Error creating project structure: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/implement_feature', methods=['POST'])
def implement_feature():
    try:
        feature_description = request.json['feature_description']
        existing_code = request.json.get('existing_code')
        new_code = agent.implement_feature(feature_description, existing_code)
        return jsonify({"code": new_code}), 200
    except Exception as e:
        logger.error(f"Error implementing feature: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/review_code', methods=['POST'])
def review_code():
    try:
        code = request.json['code']
        review = agent.review_code(code)
        return jsonify({"review": review}), 200
    except Exception as e:
        logger.error(f"Error reviewing code: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/optimize_code', methods=['POST'])
def optimize_code():
    try:
        code = request.json['code']
        optimization_goal = request.json['optimization_goal']
        optimized_code = agent.optimize_code(code, optimization_goal)
        return jsonify({"optimized_code": optimized_code}), 200
    except Exception as e:
        logger.error(f"Error optimizing code: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/generate_documentation', methods=['POST'])
def generate_documentation():
    try:
        code = request.json['code']
        documentation = agent.generate_documentation(code)
        return jsonify({"documentation": documentation}), 200
    except Exception as e:
        logger.error(f"Error generating documentation: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/suggest_tests', methods=['POST'])
def suggest_tests():
    try:
        code = request.json['code']
        test_suggestions = agent.suggest_tests(code)
        return jsonify({"test_suggestions": test_suggestions}), 200
    except Exception as e:
        logger.error(f"Error suggesting tests: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/explain_code', methods=['POST'])
def explain_code():
    try:
        code = request.json['code']
        explanation = agent.explain_code(code)
        return jsonify({"explanation": explanation}), 200
    except Exception as e:
        logger.error(f"Error explaining code: {str(e)}")
        return jsonify({"error": str(e)}), 400

@app.route('/suggest_refactoring', methods=['POST'])
def suggest_refactoring():
    try:
        code = request.json['code']
        refactoring_suggestions = agent.suggest_refactoring(code)
        return jsonify({"refactoring_suggestions": refactoring_suggestions}), 200
    except Exception as e:
        logger.error(f"Error suggesting refactoring: {str(e)}")
        return jsonify({"error": str(e)}), 400

if __name__ == '__main__':
    app.run(debug=os.getenv('FLASK_DEBUG', 'False') == 'True', host='0.0.0.0', port=int(os.getenv('PORT', 5000)))