maya-cli 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

maya_cli/cli.py

@@ -1,16 +1,33 @@
 import os
+import sys
 import click
 import logging
+import importlib.util
+from dotenv import load_dotenv, set_key
+import openai
 from .project_generator import create_project_structure, PROJECT_STRUCTURE
+from .refactor import process_directory
+from maya_cli.scripts import optimize  # This will trigger optimize_event_handler automatically
+
 
 # Setup logging
-logging.basicConfig(filename="maya_cli.log", level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+LOG_FILE = "maya_cli.log"
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# Load environment variables from .env
+load_dotenv()
+
 
 @click.group()
 def maya():
     """Maya CLI - AI Project Generator"""
     pass
 
+
 @click.command()
 @click.argument("project_name")
 def create(project_name):
@@ -26,12 +43,525 @@ def create(project_name):
         create_project_structure(base_path, PROJECT_STRUCTURE)
         click.echo(f"✅ AI project '{project_name}' created successfully!")
         logging.info(f"Project '{project_name}' created successfully at {base_path}")
-    
+
     except Exception as e:
         logging.error(f"Error while creating project: {str(e)}")
         click.echo(f"❌ An error occurred: {str(e)}")
 
+@click.command()
+@click.argument("path", nargs=-1, required=True)
+def check_best_practices(path):
+    """CLI Command: maya check-best-practices [folder] [sub-folder] ... [filename]"""
+    click.echo("🚀 Running Best Practices Check...")
+    
+    base_path = os.getcwd()
+    target_path = os.path.join(base_path, *path)
+    
+    if not os.path.exists(target_path):
+        click.echo(f"❌ Path '{target_path}' does not exist.")
+        return
+    
+    if os.path.isdir(target_path):
+        process_directory(target_path)
+    elif os.path.isfile(target_path):
+        process_directory(os.path.dirname(target_path), os.path.basename(target_path))
+    else:
+        click.echo("❌ Invalid path provided.")
+        return
+    
+    click.echo("✅ Best practices check completed!")
+
+
+@click.command()
+@click.argument("key")
+@click.argument("value")
+def set_env(key, value):
+    """Set an environment variable in .env file"""
+    env_file = ".env"
+    
+    try:
+        if not os.path.exists(env_file):
+            with open(env_file, "w") as f:
+                f.write("# Maya CLI Environment Variables\n")
+            logging.info("Created new .env file.")
+
+        set_key(env_file, key, value)
+        click.echo(f"✅ Environment variable '{key}' set successfully!")
+        logging.info(f"Set environment variable: {key}={value}")
+
+    except Exception as e:
+        logging.error(f"Error setting environment variable {key}: {str(e)}")
+        click.echo(f"❌ Error setting environment variable: {str(e)}")
+
+@click.command()
+@click.argument("parent_folder", required=True)
+@click.argument("sub_folder", required=True)
+@click.argument("filename", required=True)
+def optimize(parent_folder, sub_folder, filename):
+    """Optimize a file by importing optimize.py from maya_cli.scripts."""
+    
+    # Construct the full file path
+    target_path = os.path.abspath(os.path.join(parent_folder, sub_folder, filename))
+
+    if not os.path.isfile(target_path):
+        click.echo(f"❌ Error: '{target_path}' is not a valid file.")
+        logging.error(f"Invalid file provided: {target_path}")
+        return
+
+    # Inject the import statement into the file
+    inject_import(target_path)
+
+def inject_import(filepath):
+    """Inject import statement for optimize.py into the target file."""
+    try:
+        import_statement = "from maya_cli.scripts import optimize\n"
+
+        with open(filepath, "r+", encoding="utf-8") as f:
+            content = f.readlines()
+            
+            # Check if the import already exists
+            if any(line.strip() == import_statement.strip() for line in content):
+                click.echo(f"✅ {filepath} already imports optimize.py.")
+                return
+            
+            # Insert import at the top
+            content.insert(0, import_statement)
+            f.seek(0)
+            f.writelines(content)
+
+        click.echo(f"✅ Imported optimize.py into {filepath}")
+        logging.info(f"Imported optimize.py into {filepath}")
+
+    except Exception as e:
+        logging.error(f"Error injecting import into '{filepath}': {str(e)}")
+        click.echo(f"❌ Error injecting import into '{filepath}': {str(e)}")
+
+import os
+import json
+import click
+import logging
+import openai
+
+@click.command()
+@click.argument("parent_folder", required=True)
+@click.argument("sub_folder", required=True)
+@click.argument("filename", required=True)
+def is_secured(parent_folder, sub_folder, filename):
+    """Check and enforce API security measures: Authentication, Encryption, and Rate Limiting."""
+    click.echo("🔍 Running API Security Check...")
+
+    # Construct the full file path
+    target_path = os.path.abspath(os.path.join(parent_folder, sub_folder, filename))
+
+    if not os.path.isfile(target_path):
+        click.echo(f"❌ Error: '{target_path}' is not a valid file.")
+        logging.error(f"Invalid file provided: {target_path}")
+        return
+
+    try:
+        with open(target_path, "r", encoding="utf-8") as f:
+            code_content = f.read()
+
+        # Validate security using AI
+        validation_feedback = validate_security_with_ai(code_content)
+        security_issues = []
+
+        if not validation_feedback.get("authentication", False):
+            security_issues.append(f"❌ Missing API Authentication. Applying OAuth/API Key authentication.")
+            apply_api_authentication(target_path)
+
+        if not validation_feedback.get("encryption", False):
+            security_issues.append(f"❌ Missing Data Encryption. Implementing encryption protocols.")
+            apply_data_encryption(target_path)
+
+        if not validation_feedback.get("rate_limiting", False):
+            security_issues.append(f"❌ No Rate Limiting detected. Implementing rate limiting & quotas.")
+            apply_rate_limiting(target_path)
+
+        if security_issues:
+            for issue in security_issues:
+                click.echo(f"⚠️ {issue}")
+            click.echo("✅ Security measures have been enforced!")
+        else:
+            click.echo("✅ API usage is secure. No changes needed.")
+
+    except Exception as e:
+        logging.error(f"❌ Error processing {target_path}: {str(e)}")
+        click.echo(f"❌ Error processing {target_path}: {str(e)}")
+
+    logging.info("API Security Check Completed.")
+
+
+def validate_security_with_ai(code):
+    """Use OpenAI to validate security measures in the given code."""
+    prompt = f"""
+    Analyze the following Python code for API security vulnerabilities.
+    Identify if the code implements:
+    1. Secure API Authentication (OAuth or API Keys)
+    2. Proper Data Encryption Protocols for sensitive data
+    3. Rate Limiting and Quotas to prevent API abuse
+
+    Return a JSON response with keys: authentication, encryption, rate_limiting, each set to True or False.
+
+    Code:
+    ```
+    {code}
+    ```
+    """
+
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[{"role": "system", "content": prompt}],
+        )
+
+        result = response["choices"][0]["message"]["content"]
+        return json.loads(result)
+
+    except Exception as e:
+        logging.error(f"Error in AI validation: {str(e)}")
+        return {"authentication": False, "encryption": False, "rate_limiting": False}
+
+
+def apply_api_authentication(filepath):
+    """Apply OAuth or API Key authentication to the specified file."""
+    logging.info(f"Applying OAuth/API Key Authentication to {filepath}.")
+    with open(filepath, "a", encoding="utf-8") as f:
+        f.write("\n# TODO: Implement OAuth/API Key Authentication\n")
+
+
+def apply_data_encryption(filepath):
+    """Implement data encryption protocols in the specified file."""
+    logging.info(f"Applying Data Encryption Protocols to {filepath}.")
+    with open(filepath, "a", encoding="utf-8") as f:
+        f.write("\n# TODO: Implement Data Encryption\n")
+
+
+def apply_rate_limiting(filepath):
+    """Implement API rate limiting and quotas in the specified file."""
+    logging.info(f"Applying Rate Limiting & Quotas to {filepath}.")
+    with open(filepath, "a", encoding="utf-8") as f:
+        f.write("\n# TODO: Enforce API Rate Limiting & Quotas\n")
+
+@click.command()
+@click.argument("parent_folder", required=True)
+@click.argument("sub_folder", required=True)
+@click.argument("filename", required=False)
+def check_ethics(parent_folder, sub_folder, filename=None):
+    """Check code for efficiency, accuracy, and best practices."""
+    click.echo("\U0001F50D Running Code Ethics Check...")
+    ethics_issues = []
+
+    # Construct the full path
+    target_path = os.path.abspath(os.path.join(parent_folder, sub_folder))
+    
+    if not os.path.isdir(target_path):
+        click.echo(f"❌ Error: '{target_path}' is not a valid directory.")
+        logging.error(f"Invalid directory provided: {target_path}")
+        return
+
+    # Determine files to check
+    if filename:
+        files_to_check = [os.path.join(target_path, filename)]
+        if not os.path.isfile(files_to_check[0]):
+            click.echo(f"❌ Error: '{files_to_check[0]}' is not a valid file.")
+            logging.error(f"Invalid file provided: {files_to_check[0]}")
+            return
+    else:
+        files_to_check = [
+            os.path.join(target_path, f) for f in os.listdir(target_path) if f.endswith(".py")
+        ]
+
+    for file in files_to_check:
+        try:
+            with open(file, "r", encoding="utf-8") as f:
+                code_content = f.read()
+
+            # Validate ethics using AI
+            validation_feedback = validate_ethics_with_ai(code_content)
+
+            if not validation_feedback.get("efficiency", False):
+                ethics_issues.append(f"{file}: Code may have performance inefficiencies.")
+
+            if not validation_feedback.get("accuracy", False):
+                ethics_issues.append(f"{file}: Code accuracy needs review for correctness.")
+
+            if not validation_feedback.get("best_practices", False):
+                ethics_issues.append(f"{file}: Code may not follow industry best practices.")
+
+        except Exception as e:
+            logging.error(f"❌ Error processing {file}: {str(e)}")
+            click.echo(f"❌ Error processing {file}: {str(e)}")
+
+    if ethics_issues:
+        for issue in ethics_issues:
+            click.echo(f"⚠️ {issue}")
+        click.echo("✅ Ethics Review Completed with Recommendations!")
+    else:
+        click.echo("✅ Code meets ethical standards. No issues detected.")
+
+    logging.info("Code Ethics Check Completed.")
+
+
+def validate_ethics_with_ai(code):
+    """Use OpenAI to validate code ethics, efficiency, and best practices."""
+    prompt = f"""
+    Analyze the following Python code for ethical concerns in:
+    1. Efficiency (performance optimization, unnecessary loops, redundant code)
+    2. Accuracy (logical correctness, potential calculation errors)
+    3. Best Practices (PEP8 compliance, maintainability, documentation)
+
+    Return a JSON response with keys: efficiency, accuracy, best_practices, each set to True or False.
+
+    Code:
+    ```
+    {code}
+    ```
+    """
+
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[{"role": "system", "content": prompt}],
+        )
+
+        result = response["choices"][0]["message"]["content"]
+        return json.loads(result)
+
+    except Exception as e:
+        logging.error(f"Error in AI validation: {str(e)}")
+        return {"efficiency": False, "accuracy": False, "best_practices": False}
+
+@click.command()
+@click.argument("parent_folder")
+@click.argument("sub_folder")
+@click.argument("filename")
+def doc(parent_folder, sub_folder, filename):
+    """Generate README.md documentation for the given file."""
+    click.echo("📄 Generating Documentation...")
+
+    # Construct the full file path
+    target_path = os.path.join(parent_folder, sub_folder)
+    file_path = os.path.join(target_path, filename)
+
+    # Validate directory existence
+    if not os.path.isdir(target_path):
+        click.echo(f"❌ Error: The directory '{target_path}' does not exist.")
+        return
+
+    # Validate file existence
+    if not os.path.isfile(file_path):
+        click.echo(f"❌ Error: The file '{file_path}' does not exist in the specified directory.")
+        return
+
+    readme_path = os.path.join(target_path, "README.md")
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as source_file:
+            code_content = source_file.read()
+
+        # Generate documentation (Placeholder function, replace with AI-based generation)
+        documentation = generate_documentation(code_content)
+
+        # Write to README.md
+        with open(readme_path, "w", encoding="utf-8") as readme_file:
+            readme_file.write(documentation)
+
+        click.echo(f"✅ Documentation created for {file_path} -> {readme_path}")
+
+    except Exception as e:
+        logging.error(f"❌ Error processing {file_path}: {str(e)}")
+        click.echo(f"❌ Error processing {file_path}: {str(e)}")
+
+def generate_documentation(code):
+    """Generate structured documentation based on the given Python code."""
+    return f"# Auto-Generated Documentation\n\n```python\n{code}\n```"
+
+@click.command()
+@click.argument("parent_folder")
+@click.argument("sub_folder")
+@click.argument("filename", required=False)
+def codex(parent_folder, sub_folder, filename=None):
+    """Provide in-depth analysis and recommendations for a file or all Python files in a directory."""
+    click.echo("📚 Creating Code Codex Report...")
+
+    # Construct the full target path
+    target_path = os.path.join(parent_folder, sub_folder)
+
+    # Validate directory existence
+    if not os.path.isdir(target_path):
+        click.echo(f"❌ Error: The directory '{target_path}' does not exist.")
+        return
+
+    # Determine files to analyze
+    if filename:
+        file_path = os.path.join(target_path, filename)
+        if not os.path.isfile(file_path):
+            click.echo(f"❌ Error: The file '{file_path}' does not exist in the specified directory.")
+            return
+        files_to_analyze = [file_path]
+    else:
+        files_to_analyze = [os.path.join(target_path, f) for f in os.listdir(target_path) if f.endswith(".py")]
+
+    if not files_to_analyze:
+        click.echo("⚠️ No Python files found in the specified directory.")
+        return
+
+    for file in files_to_analyze:
+        codex_report_path = os.path.join(".\\docs/", "CODEX_REPORT.md")
+
+        try:
+            with open(file, "r", encoding="utf-8") as source_file:
+                code_content = source_file.read()
+
+            # Generate codex report (Placeholder function, replace with AI-based analysis)
+            report = generate_codex_report(code_content)
+
+            # Write report to CODEX_REPORT.md
+            with open(codex_report_path, "w", encoding="utf-8") as report_file:
+                report_file.write(report)
+
+            click.echo(f"✅ Codex Report generated for {file} -> {codex_report_path}")
+
+        except Exception as e:
+            logging.error(f"❌ Error processing {file}: {str(e)}")
+            click.echo(f"❌ Error processing {file}: {str(e)}")
+
+def generate_codex_report(code):
+    """Generate an in-depth analysis and recommendations based on the given Python code."""
+    return f"# Code Analysis & Recommendations\n\n```python\n{code}\n```\n\n## Recommendations:\n- Improve efficiency\n- Enhance readability\n- Optimize performance\n"
+
+@click.command()
+@click.argument("parent_folder")
+@click.argument("sub_folder")
+@click.argument("filename", required=False)
+def regulate(parent_folder, sub_folder, filename=None):
+    """Ensure code compliance with GDPR, CCPA, AI Act, and ISO 42001 AI governance standards."""
+    click.echo("🔍 Running Compliance & Regulation Check...")
+
+    compliance_issues = []
+
+    # Construct the full target path
+    target_path = os.path.join(parent_folder, sub_folder)
+
+    # Validate directory existence
+    if not os.path.isdir(target_path):
+        click.echo(f"❌ Error: The directory '{target_path}' does not exist.")
+        return
+
+    # Determine files to check
+    if filename:
+        file_path = os.path.join(target_path, filename)
+        if not os.path.isfile(file_path):
+            click.echo(f"❌ Error: The file '{file_path}' does not exist in the specified directory.")
+            return
+        files_to_check = [file_path]
+    else:
+        files_to_check = [os.path.join(target_path, f) for f in os.listdir(target_path) if f.endswith(".py")]
+
+    if not files_to_check:
+        click.echo("⚠️ No Python files found in the specified directory.")
+        return
+
+    for file in files_to_check:
+        compliance_report_path = os.path.join("./configs/", "COMPLIANCE_REPORT.md")
+
+        try:
+            with open(file, "r", encoding="utf-8") as f:
+                code_content = f.read()
+
+            # Validate compliance (Placeholder function, replace with AI-based analysis)
+            compliance_feedback = validate_compliance_with_ai(code_content)
+
+            # Track issues and apply fixes
+            if not compliance_feedback.get("gdpr", False):
+                compliance_issues.append(f"{file}: GDPR compliance issues detected. Adjusting for data privacy.")
+                apply_gdpr_compliance(file)
+
+            if not compliance_feedback.get("ccpa", False):
+                compliance_issues.append(f"{file}: CCPA compliance issues detected. Ensuring consumer rights protection.")
+                apply_ccpa_compliance(file)
+
+            if not compliance_feedback.get("ai_act", False):
+                compliance_issues.append(f"{file}: AI Act risk classification missing. Implementing compliance measures.")
+                apply_ai_act_compliance(file)
+
+            if not compliance_feedback.get("iso_42001", False):
+                compliance_issues.append(f"{file}: ISO 42001 AI governance framework not followed. Adjusting AI management protocols.")
+                apply_iso_42001_compliance(file)
+
+            # Generate compliance report
+            with open(compliance_report_path, "w", encoding="utf-8") as report_file:
+                report_file.write(generate_compliance_report(file, compliance_feedback))
+
+            click.echo(f"✅ Compliance report generated for {file} -> {compliance_report_path}")
+
+        except Exception as e:
+            logging.error(f"❌ Error processing {file}: {str(e)}")
+            click.echo(f"❌ Error processing {file}: {str(e)}")
+
+    if compliance_issues:
+        for issue in compliance_issues:
+            click.echo(f"⚠️ {issue}")
+        click.echo("✅ Compliance measures have been enforced!")
+    else:
+        click.echo("✅ Code meets all compliance regulations. No changes needed.")
+
+    logging.info("Compliance & Regulation Check Completed.")
+
+def validate_compliance_with_ai(code):
+    """Analyze code for compliance with GDPR, CCPA, AI Act, and ISO 42001."""
+    return {
+        "gdpr": True, 
+        "ccpa": True, 
+        "ai_act": False, 
+        "iso_42001": False
+    }  # Replace with AI-based compliance validation
+
+def apply_gdpr_compliance(filepath):
+    logging.info(f"Applying GDPR compliance to {filepath}.")
+
+def apply_ccpa_compliance(filepath):
+    logging.info(f"Applying CCPA compliance to {filepath}.")
+
+def apply_ai_act_compliance(filepath):
+    logging.info(f"Applying AI Act compliance to {filepath}.")
+
+def apply_iso_42001_compliance(filepath):
+    logging.info(f"Applying ISO 42001 AI governance framework to {filepath}.")
+
+def generate_compliance_report(filepath, feedback):
+    """Generate a structured compliance report."""
+    return f"""
+# Compliance Report for {os.path.basename(filepath)}
+
+## Compliance Status:
+- **GDPR:** {"✅ Compliant" if feedback.get("gdpr") else "❌ Not Compliant"}
+- **CCPA:** {"✅ Compliant" if feedback.get("ccpa") else "❌ Not Compliant"}
+- **AI Act:** {"✅ Compliant" if feedback.get("ai_act") else "❌ Not Compliant"}
+- **ISO 42001:** {"✅ Compliant" if feedback.get("iso_42001") else "❌ Not Compliant"}
+
+## Recommendations:
+- { "Ensure data privacy measures are in place." if not feedback.get("gdpr") else "GDPR compliance verified." }
+- { "Strengthen consumer rights protection." if not feedback.get("ccpa") else "CCPA compliance verified." }
+- { "Classify AI system under the AI Act risk framework." if not feedback.get("ai_act") else "AI Act compliance verified." }
+- { "Align with ISO 42001 AI governance framework." if not feedback.get("iso_42001") else "ISO 42001 compliance verified." }
+
+---
+
+🛠 *Generated by Compliance Checker*
+"""
+
+# Add commands to Maya CLI
+maya.add_command(is_secured)
+maya.add_command(check_ethics)
+maya.add_command(doc)
+maya.add_command(codex)
+maya.add_command(regulate)
 maya.add_command(create)
+maya.add_command(check_best_practices)
+maya.add_command(set_env)
+maya.add_command(optimize)
 
 if __name__ == "__main__":
     maya()

maya_cli/project_generator.py

@@ -1,5 +1,14 @@
-# project_generator.py 
+# project_generator.py
 import os
+import logging
+
+# Configure logging
+LOG_FILE = "project_generator.log"
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
 
 # Define the AI Project Structure
 PROJECT_STRUCTURE = {
@@ -10,19 +19,55 @@ PROJECT_STRUCTURE = {
     "tests": {},
     "docs": {},
     "scripts": {},
-    "configs": {}
+    "configs": {},
+    "": {"main.py", "requirements.txt"},
 }
 
-# Function to create folders
 def create_project_structure(base_path, structure):
-    for folder, subfolders in structure.items():
-        folder_path = os.path.join(base_path, folder)
-        os.makedirs(folder_path, exist_ok=True)
-        
-        # Create __init__.py for package folders
-        init_file = os.path.join(folder_path, "__init__.py")
-        with open(init_file, "w") as f:
-            f.write(f"# {folder.replace('_', ' ').title()} package\n")
-        
-        if isinstance(subfolders, dict):
-            create_project_structure(folder_path, subfolders)
+    """Creates the AI project directory structure with logging and error handling."""
+    try:
+        if not os.path.exists(base_path):
+            os.makedirs(base_path)
+            logging.info(f"Created base project directory: {base_path}")
+
+        for folder, subfolders in structure.items():
+            folder_path = os.path.join(base_path, folder)
+            try:
+                os.makedirs(folder_path, exist_ok=True)
+                logging.info(f"Created folder: {folder_path}")
+
+                # Create __init__.py for package folders
+                init_file = os.path.join(folder_path, "__init__.py")
+                with open(init_file, "w") as f:
+                    f.write(f"# {folder.replace('_', ' ').title()} package\n")
+                logging.info(f"Created __init__.py in: {folder_path}")
+
+            except PermissionError:
+                logging.error(f"Permission denied: Unable to create {folder_path}")
+            except Exception as e:
+                logging.error(f"Error creating folder {folder_path}: {str(e)}")
+
+            if isinstance(subfolders, dict):
+                create_project_structure(folder_path, subfolders)
+
+            # Handle single files in the root project
+            if isinstance(subfolders, set):
+                for file in subfolders:
+                    file_path = os.path.join(base_path, file)
+                    try:
+                        with open(file_path, "w") as f:
+                            f.write(f"# {file} generated by project generator\n")
+                        logging.info(f"Created file: {file_path}")
+                    except PermissionError:
+                        logging.error(f"Permission denied: Unable to create {file_path}")
+                    except Exception as e:
+                        logging.error(f"Error creating file {file_path}: {str(e)}")
+
+    except Exception as e:
+        logging.critical(f"Critical error in project generation: {str(e)}")
+
+# Example Usage
+if __name__ == "__main__":
+    BASE_PATH = "My_AI_Project"
+    create_project_structure(BASE_PATH, PROJECT_STRUCTURE)
+    print("✅ AI project structure generated. Check logs for details.")

maya_cli/refactor.py

@@ -0,0 +1,111 @@
+import os
+import click
+import openai
+import logging
+
+# Setup logging
+LOG_FILE = "maya_refactor.log"
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# OpenAI API Key (Ensure it's set as an environment variable)
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+def read_file(file_path):
+    """Reads the content of a file."""
+    try:
+        with open(file_path, "r", encoding="utf-8") as file:
+            content = file.read()
+        logging.info(f"Successfully read file: {file_path}")
+        return content
+    except FileNotFoundError:
+        error_msg = f"❌ Error: File not found - {file_path}"
+    except PermissionError:
+        error_msg = f"❌ Error: Permission denied - {file_path}"
+    except Exception as e:
+        error_msg = f"❌ Error reading {file_path}: {str(e)}"
+    
+    logging.error(error_msg)
+    click.echo(error_msg)
+    return None
+
+def write_file(file_path, content):
+    """Writes content back to the file."""
+    try:
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write(content)
+        success_msg = f"✅ Refactored and updated: {file_path}"
+        logging.info(success_msg)
+        click.echo(success_msg)
+    except PermissionError:
+        error_msg = f"❌ Error: Permission denied - {file_path}"
+    except Exception as e:
+        error_msg = f"❌ Error writing {file_path}: {str(e)}"
+    
+        logging.error(error_msg)
+        click.echo(error_msg)
+
+def refactor_code_with_openai(code):
+    """Sends code to OpenAI for best-practices refactoring."""
+    prompt = f"""
+    Refactor the following Python code following best practices for AI API development:
+    - Clean code structure
+    - Improve readability & maintainability
+    - Optimize performance & scalability
+    - Ensure proper exception handling
+    - Secure API keys and authentication
+
+    Code:
+    \"\"\"{code}\"\"\"
+
+    Optimized Code:
+    """
+
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "You are an expert AI code reviewer."},
+                {"role": "user", "content": prompt}
+            ]
+        )
+        optimized_code = response["choices"][0]["message"]["content"].strip()
+        logging.debug(f"OpenAI API response received successfully.")
+        return optimized_code
+    except openai.OpenAIError as e:  # Corrected
+        error_msg = f"❌ OpenAI API Error: {str(e)}"
+    except Exception as e:
+        error_msg = f"❌ Unexpected Error: {str(e)}"
+
+    logging.error(error_msg)
+    click.echo(error_msg)
+    return code  # Return original code if API call fails
+
+
+def process_directory(directory, filename=None):
+    """Scans the given directory and refactors specified files."""
+    if not os.path.exists(directory):
+        click.echo(f"❌ Error: Directory '{directory}' not found.")
+        logging.error(f"Directory '{directory}' does not exist.")
+        return
+
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if filename and file != filename:
+                continue  # Skip files that don't match
+            
+            file_path = os.path.join(root, file)
+            if file.endswith(".py"):  # Only process Python files
+                click.echo(f"🔍 Checking: {file_path}")
+                logging.info(f"Processing file: {file_path}")
+                
+                code = read_file(file_path)
+                if code:
+                    refactored_code = refactor_code_with_openai(code)
+                    write_file(file_path, refactored_code)
+
+    click.echo("✅ Best practices check completed!")
+    logging.info("Best practices check completed successfully.")

maya_cli/scripts/__init__.py

@@ -0,0 +1 @@
+# __init__

maya_cli/scripts/optimize.py

@@ -0,0 +1,151 @@
+import os
+import json
+import asyncio
+import logging
+import functools
+import threading
+from datetime import datetime, timedelta
+from collections import defaultdict
+from dotenv import load_dotenv
+import openai
+import aiohttp
+
+# Load environment variables
+load_dotenv()
+
+# Setup logging
+LOG_FILE = "maya_optimize.log"
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# Cache storage
+CACHE_FILE = "maya_cache.json"
+cache = {}
+
+# Batch requests queue
+BATCH_REQUESTS = defaultdict(list)
+BATCH_SIZE = 5
+BATCH_TIME_LIMIT = 10  # seconds
+
+# Load API key
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+
+# 🔄 **Load Cache from File**
+def load_cache():
+    global cache
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                cache = json.load(f)
+                logging.info("Cache loaded successfully.")
+        except Exception as e:
+            logging.error(f"Failed to load cache: {str(e)}")
+
+
+# 💾 **Save Cache to File**
+def save_cache():
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache, f, indent=4)  # Added indentation for readability
+        logging.info("Cache saved successfully.")
+    except Exception as e:
+        logging.error(f"Failed to save cache: {str(e)}")
+
+
+# 🚀 **Cache Wrapper for API Calls**
+def cache_results(ttl=300):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            key = f"{func.__name__}:{args}:{kwargs}"
+            now = datetime.utcnow()
+
+            # Check cache
+            if key in cache and now - datetime.fromisoformat(cache[key]["timestamp"]) < timedelta(seconds=ttl):
+                logging.info(f"Cache hit for {key}")
+                return cache[key]["result"]
+
+            # Execute function & store result
+            result = func(*args, **kwargs)
+            cache[key] = {"timestamp": now.isoformat(), "result": result}
+            save_cache()  # Save cache immediately after update
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+# ⚡ **Async API Call Optimization**
+async def async_openai_request(prompt):
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {openai.api_key}",
+        "Content-Type": "application/json",
+    }
+    data = {
+        "model": "gpt-4",
+        "messages": [{"role": "user", "content": prompt}],
+    }
+
+    try:
+        start_time = datetime.utcnow()
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, headers=headers, json=data, timeout=10) as response:
+                response_data = await response.json()
+        
+        end_time = datetime.utcnow()
+        logging.info(f"OpenAI request completed in {(end_time - start_time).total_seconds()} seconds.")
+        return response_data
+
+    except asyncio.TimeoutError:
+        logging.error("OpenAI request timed out.")
+        return {"error": "Request timed out"}
+    except Exception as e:
+        logging.error(f"OpenAI request failed: {str(e)}")
+        return {"error": "Request failed"}
+
+
+# 🚀 **Batch Processing API Calls**
+async def process_batch_requests():
+    while True:
+        if BATCH_REQUESTS:
+            for key, prompts in list(BATCH_REQUESTS.items()):
+                if len(prompts) >= BATCH_SIZE:
+                    logging.info(f"Processing batch of {len(prompts)} requests.")
+                    batch_response = await asyncio.gather(
+                        *[async_openai_request(prompt) for prompt in prompts]
+                    )
+                    for i, response in enumerate(batch_response):
+                        BATCH_REQUESTS[key][i] = response
+                    del BATCH_REQUESTS[key]
+
+        await asyncio.sleep(BATCH_TIME_LIMIT)
+
+
+# 🔍 **Fine-Tuning Models (Placeholder)**
+def fine_tune_model():
+    """Future placeholder for fine-tuning AI models based on performance metrics."""
+    logging.info("Fine-tuning models is not yet implemented.")
+
+
+# 🛠 **Optimization Event Listener (Runs in Background)**
+def optimize_event_handler():
+    logging.info("Optimization event listener started.")
+
+    def run_event_loop():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(process_batch_requests())
+
+    # Run the event loop in a background thread
+    threading.Thread(target=run_event_loop, daemon=True).start()
+
+
+# 🔥 **Auto-Run When Imported**
+load_cache()
+optimize_event_handler()  # Now runs in the background instead of blocking the main thread

maya_cli-0.1.3.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.2
+Name: maya-cli
+Version: 0.1.3
+Summary: Maya CLI - AI Project Generator
+Home-page: https://github.com/anointingmayami/Maya.ai
+Author: King Anointing Joseph Mayami
+Author-email: anointingmayami@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: click
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Maya CLI - Developer Documentation
+
+## Overview
+Maya CLI is a command-line interface (CLI) designed to assist in AI project generation, optimization, security enforcement, and best practices validation. This documentation provides a guide on how to use each CLI command effectively.
+
+## Installation
+Before using Maya CLI, ensure that the required dependencies are installed:
+```sh
+pip install -r requirements.txt
+```
+
+## Commands
+### 1. Create a New AI Project
+#### Command:
+```sh
+maya create <project_name>
+```
+#### Description:
+Creates a new AI project structure.
+
+#### Example:
+```sh
+maya create my_ai_project
+```
+
+### 2. Check Best Practices
+#### Command:
+```sh
+maya check_best_practices [folder] [filename]
+```
+#### Description:
+Validates Python code against best practices.
+
+#### Example:
+```sh
+maya check_best_practices api my_script.py
+```
+
+### 3. Set Environment Variable
+#### Command:
+```sh
+maya set_env <key> <value>
+```
+#### Description:
+Sets a key-value pair in the `.env` file.
+
+#### Example:
+```sh
+maya set_env OPENAI_API_KEY my_api_key
+```
+
+### 4. Optimize AI Scripts
+#### Command:
+```sh
+maya optimize [target]
+```
+#### Description:
+Optimizes AI scripts with caching and async processing.
+
+#### Example:
+```sh
+maya optimize my_project
+```
+
+### 5. Enforce API Security
+#### Command:
+```sh
+maya isSecured <target> [filename]
+```
+#### Description:
+Checks and enforces API security measures including authentication, encryption, and rate limiting.
+
+#### Example:
+```sh
+maya isSecured api my_api.py
+```
+
+### 6. Check Code Ethics
+#### Command:
+```sh
+maya check_ethics <target> [filename]
+```
+#### Description:
+Validates code efficiency, accuracy, and best practices.
+
+#### Example:
+```sh
+maya check_ethics my_project
+```
+
+### 7. Generate Documentation
+#### Command:
+```sh
+maya doc <target> <filename>
+```
+#### Description:
+Generates a `README.md` documentation for the given file.
+
+#### Example:
+```sh
+maya doc api my_script.py
+```
+
+### 8. Generate Codex Report
+#### Command:
+```sh
+maya codex <target> <filename>
+```
+#### Description:
+Provides an in-depth analysis and recommendations for the given file.
+
+#### Example:
+```sh
+maya codex ai_model model.py
+```
+
+### 9. Enforce Compliance & Regulation
+#### Command:
+```sh
+maya regulate <target> [filename]
+```
+#### Description:
+Ensures compliance with GDPR, CCPA, AI Act, and ISO 42001 AI governance standards.
+
+#### Example:
+```sh
+maya regulate my_project
+```
+
+## Logging
+Maya CLI logs all operations in `maya_cli.log`. Check this file for debugging and issue tracking.
+
+## Contact
+For support or feature requests, reach out to the development team via GitHub or email.

maya_cli-0.1.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+maya_cli/__init__.py,sha256=d7ktJFCti7GbZZJJHwTLpLy9EyI3lJmkqtL3YnR-cm8,69
+maya_cli/cli.py,sha256=jwOLoXsmz9Af41-tyukTmGMORjBoz8hJ9QikxdgbIFs,21928
+maya_cli/project_generator.py,sha256=AB9uV_lBe-KPywMJ3uDH9YPSTRHXFP7qzqpPdxDB5GY,2967
+maya_cli/refactor.py,sha256=ipi3iabQOcyQyJn20PErpgi-Hb4cb8f8p7zW0HO22_s,3890
+maya_cli/scripts/__init__.py,sha256=yY3Tbs-t4HSl4I0Ev0RcHMnHU7SwljlWRveiRJkeCB8,10
+maya_cli/scripts/optimize.py,sha256=UqDIHyyYPXZkhAb4GSvjbN0IvwXM2aFnpSh4k0Jzobo,4820
+maya_cli-0.1.3.dist-info/METADATA,sha256=mPsFwPZ9C399qTlHxcHC7TpSoHNn6hr-_46XlAjBaes,3469
+maya_cli-0.1.3.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+maya_cli-0.1.3.dist-info/entry_points.txt,sha256=K4mI6r7-idKvOmz7zpMpK6HaEnraRoRt4nSW1jTfCgE,43
+maya_cli-0.1.3.dist-info/top_level.txt,sha256=nZzw8c5hxqres4pU9UUFCTjwBSHUDNjqCTM7yOFnnrE,9
+maya_cli-0.1.3.dist-info/RECORD,,

{maya_cli-0.1.1.dist-info → maya_cli-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

maya_cli-0.1.1.dist-info/METADATA

@@ -1,116 +0,0 @@
-Metadata-Version: 2.2
-Name: maya-cli
-Version: 0.1.1
-Summary: Maya CLI - AI Project Generator
-Home-page: https://github.com/anointingmayami/Maya.ai
-Author: King Anointing Joseph Mayami
-Author-email: anointingmayami@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: click
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Maya.ai - AI Architectural Framework
-
-Maya.ai is an AI architectural framework designed to ensure ethical, optimized, and compliant AI integration in business and research applications. The framework provides guidance on AI ethics, compliance, business strategy, and AI-driven education while fostering innovation.
-
-## 🌟 Features
-- Ensures structured AI project development
-- Promotes ethical and compliant AI integration
-- Provides a scalable framework for AI research and business applications
-- Includes Maya CLI for quick AI project setup
-
-## 🛠 Maya CLI - AI Project Generator
-Maya CLI is one of the core features of Maya.ai, designed to generate structured AI project templates. It helps AI developers quickly set up their projects with predefined folders and files, ensuring organization and scalability.
-
-### 📦 Installation Guide (For Dummies)
-
-#### Step 1: Install Python
-Maya CLI requires Python. To install Python:
-- Download the latest version of Python from [python.org](https://www.python.org/downloads/)
-- Run the installer and ensure "Add Python to PATH" is checked
-- Verify installation by running:
-  ```sh
-  python --version
-  ```
-
-#### Step 2: Install Virtual Environment (Optional but Recommended)
-Using a virtual environment helps manage dependencies. Install it using:
-```sh
-pip install virtualenv
-```
-To create and activate a virtual environment:
-```sh
-virtualenv venv
-source venv/bin/activate  # On macOS/Linux
-venv\Scripts\activate     # On Windows
-```
-
-#### Step 3: Install Maya CLI
-Maya CLI is available on PyPI. Install it using pip:
-```sh
-pip install maya-cli
-```
-
-### 🚀 Usage
-Once installed, use the following command to create a new AI project:
-```sh
-maya create <project_name>
-```
-Example:
-```sh
-maya create my_ai_project
-```
-This will generate the following structure:
-```
-my_ai_project/
-│── data_source/
-│   ├── ingestion/
-│   ├── processing/
-│   ├── storage/
-│── knowledge_base/
-│   ├── models/
-│   ├── training/
-│   ├── evaluation/
-│── ai_governance/
-│   ├── compliance/
-│   ├── fairness/
-│   ├── monitoring/
-│── api/
-│   ├── endpoints/
-│   ├── authentication/
-│── tests/
-│── docs/
-│── scripts/
-│── configs/
-```
-
-### 🛠 API Documentation
-#### CLI Commands
-##### `maya create <project_name>`
-Creates a new AI project structure with organized folders.
-
-#### `project_generator.py`
-##### `create_project_structure(base_path, structure)`
-Recursively creates folders based on the defined project structure.
-
-## 📜 License
-This project is licensed under the MIT License.
-
-## 🤝 Contributing
-Contributions are welcome! Feel free to open an issue or submit a pull request.
-
-## 📞 Support
-For any issues, contact the developers via GitHub or raise an issue in the repository.
-

maya_cli-0.1.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-maya_cli/__init__.py,sha256=d7ktJFCti7GbZZJJHwTLpLy9EyI3lJmkqtL3YnR-cm8,69
-maya_cli/cli.py,sha256=EiIL10GcFQCdyiwyJZjOXrJ6klVQLzKYpLiG10Ph7xE,1253
-maya_cli/project_generator.py,sha256=-p7MAqnfzZthO6vKLtesRoTmUn-ZyvOBY1tcmayuPPo,1036
-maya_cli-0.1.1.dist-info/METADATA,sha256=faJGMaXqOJy65km7IMIq3AErtZn4znJdbO5iGYEq0C4,4025
-maya_cli-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-maya_cli-0.1.1.dist-info/entry_points.txt,sha256=K4mI6r7-idKvOmz7zpMpK6HaEnraRoRt4nSW1jTfCgE,43
-maya_cli-0.1.1.dist-info/top_level.txt,sha256=nZzw8c5hxqres4pU9UUFCTjwBSHUDNjqCTM7yOFnnrE,9
-maya_cli-0.1.1.dist-info/RECORD,,