main.py

"""
AI Autonomous Employee System - Advanced Features
Main entry point for the system initialization and orchestration.
"""

import os
import sys
import logging
import time
import threading
from pathlib import Path
from dotenv import load_dotenv

from agents.core.claude_agent import ClaudeAgent
from agents.core.approval_workflow import ApprovalWorkflow
from agents.core.reasoning_loop import ReasoningLoop
from agents.core.scheduler import TaskScheduler, ScheduledTasks, setup_default_schedule
from agents.core.skill_orchestrator import SkillOrchestrator
from agents.core.autonomous_loop import AutonomousLoop
from agents.skills.linkedin_skills import LinkedInPostGenerator
from agents.skills.social_media_skills import SocialMediaGenerator
from agents.skills.ceo_report_skills import CEOReportGenerator
from watchers.inbox_watcher import InboxWatcher
from watchers.gmail_watcher import GmailWatcher
from web_ui.app import run_web_ui

# Load environment variables
config_path = Path(__file__).parent / "config" / ".env"
load_dotenv(config_path)

# Configure logging
log_level = os.getenv("LOG_LEVEL", "INFO")
log_dir = Path(__file__).parent / "logs"
log_dir.mkdir(exist_ok=True)

logging.basicConfig(
    level=getattr(logging, log_level),
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(log_dir / "system.log", encoding='utf-8'),
        logging.StreamHandler(open(sys.stdout.fileno(), mode='w', encoding='utf-8', closefd=False))
    ]
)

logger = logging.getLogger(__name__)


class AIEmployeeSystem:
    """Main system orchestrator for AI Autonomous Employee - Advanced Features."""

    def __init__(self, enable_mcp_server: bool = False, enable_autonomous: bool = False):
        self.vault_path = Path(os.getenv("VAULT_PATH", "./vault"))
        self.check_interval = int(os.getenv("CHECK_INTERVAL", "300"))
        self.enable_mcp_server = enable_mcp_server
        self.enable_autonomous = enable_autonomous
        self.running = False

        # Components
        self.claude_agent = None
        self.approval_workflow = None
        self.reasoning_loop = None
        self.scheduler = None
        self.skill_orchestrator = None
        self.autonomous_loop = None

        # Watchers
        self.inbox_watcher = None
        self.gmail_watcher = None

        # Skills
        self.linkedin_generator = None
        self.social_media_generator = None
        self.ceo_report_generator = None

        # MCP Server thread
        self.mcp_thread = None

        logger.info("Initializing AI Employee System - Advanced Features")
        self._validate_environment()
        self._initialize_components()

    def _validate_environment(self):
        """Validate required environment variables and paths."""
        required_paths = [
            self.vault_path / "Inbox",
            self.vault_path / "Needs_Action",
            self.vault_path / "Done",
            self.vault_path / "Pending_Approval",
            self.vault_path / "Plans",
            self.vault_path / "Email_Inbox",
            self.vault_path / "LinkedIn_Posts",
            self.vault_path / "Business_Updates",
            self.vault_path / "Reports"
        ]

        for path in required_paths:
            path.mkdir(parents=True, exist_ok=True)

        logger.info("Environment validation passed")

    def _initialize_components(self):
        """Initialize all advanced components."""
        try:
            # Core components
            self.claude_agent = ClaudeAgent()
            logger.info("Claude agent initialized")

            self.approval_workflow = ApprovalWorkflow(self.vault_path)
            logger.info("Approval workflow initialized")

            self.reasoning_loop = ReasoningLoop(
                self.vault_path,
                self.claude_agent,
                self.approval_workflow
            )
            logger.info("Reasoning loop initialized")

            # Watchers
            self.inbox_watcher = InboxWatcher(self.vault_path, self.claude_agent)
            logger.info("Inbox watcher initialized")

            self.gmail_watcher = GmailWatcher(self.vault_path, self.claude_agent)
            logger.info("Gmail watcher initialized")

            # Skills
            self.linkedin_generator = LinkedInPostGenerator(
                self.vault_path,
                self.claude_agent,
                self.approval_workflow
            )
            logger.info("LinkedIn generator initialized")

            self.social_media_generator = SocialMediaGenerator(
                self.vault_path,
                self.claude_agent,
                self.approval_workflow
            )
            logger.info("Social media generator initialized")

            self.ceo_report_generator = CEOReportGenerator(
                self.vault_path,
                self.claude_agent
            )
            logger.info("CEO report generator initialized")

            # Skill orchestrator
            self.skill_orchestrator = SkillOrchestrator(
                self.vault_path,
                self.claude_agent,
                self.approval_workflow
            )
            logger.info("Skill orchestrator initialized")

            # Autonomous loop (if enabled)
            if self.enable_autonomous:
                self.autonomous_loop = AutonomousLoop(
                    self.vault_path,
                    self.claude_agent,
                    self.approval_workflow,
                    self.skill_orchestrator,
                    loop_interval=60
                )
                logger.info("Autonomous loop initialized")

            # Scheduler
            self.scheduler = TaskScheduler()
            scheduled_tasks = ScheduledTasks(
                self.reasoning_loop,
                self.gmail_watcher,
                self.linkedin_generator
            )
            setup_default_schedule(self.scheduler, scheduled_tasks)
            logger.info("Task scheduler initialized")

        except Exception as e:
            logger.error(f"Error initializing components: {e}")
            raise

    def start(self):
        """Start the AI Employee System - Advanced Features."""
        logger.info("Starting AI Employee System - Advanced Features")
        self.running = True

        try:
            logger.info(f"Vault path: {self.vault_path}")
            logger.info(f"Check interval: {self.check_interval}s")

            # Start inbox watcher
            self.inbox_watcher.start()
            logger.info("Inbox watcher started")

            # Start Gmail watcher
            self.gmail_watcher.start()
            logger.info("Gmail watcher started")

            # Start MCP server in separate thread if enabled
            if self.enable_mcp_server:
                self._start_mcp_server()

            # Start Web UI always
            web_host = os.getenv("WEB_UI_HOST", "127.0.0.1")
            web_port = int(os.getenv("WEB_UI_PORT", "8080"))
            web_thread = threading.Thread(
                target=run_web_ui,
                args=(web_host, web_port),
                daemon=True
            )
            web_thread.start()
            logger.info(f"Web UI started: http://{web_host}:{web_port}")

            logger.info("=" * 60)
            logger.info("ADVANCED FEATURES ACTIVE:")
            logger.info("✓ Inbox file watcher")
            logger.info("✓ Gmail watcher (simulated)")
            logger.info("✓ LinkedIn post generator")
            logger.info("✓ Social media generator (Facebook, Instagram, Twitter)")
            logger.info("✓ CEO report generator")
            logger.info("✓ Reasoning loop")
            logger.info("✓ Approval workflow")
            logger.info("✓ Skill orchestrator")
            logger.info("✓ Error handling with retry")
            logger.info("✓ Advanced logging")
            if self.enable_autonomous:
                logger.info("✓ Autonomous loop (Ralph Wiggum mode)")
            if self.enable_mcp_server:
                logger.info("✓ MCP server (http://127.0.0.1:8000)")
            logger.info("=" * 60)

            logger.info("System initialized successfully")
            logger.info("Ready to process tasks")

            # Start autonomous loop if enabled
            if self.enable_autonomous:
                logger.info("Starting autonomous loop...")
                self.autonomous_loop.start()
            else:
                # Start scheduler in separate thread
                scheduler_thread = threading.Thread(
                    target=self.scheduler.start,
                    daemon=True
                )
                scheduler_thread.start()
                logger.info("Task scheduler started")

                # Keep the main thread alive
                while self.running:
                    time.sleep(1)

        except KeyboardInterrupt:
            logger.info("Shutdown signal received")
            self.stop()
        except Exception as e:
            logger.error(f"System error: {e}", exc_info=True)
            self.stop()

    def _start_mcp_server(self):
        """Start MCP server in a separate thread."""
        try:
            from mcp_servers.email_server import run_server

            def run_mcp():
                run_server(self.vault_path, host="127.0.0.1", port=8000)

            self.mcp_thread = threading.Thread(target=run_mcp, daemon=True)
            self.mcp_thread.start()
            logger.info("MCP server started on http://127.0.0.1:8000")

        except Exception as e:
            logger.error(f"Error starting MCP server: {e}")

    def stop(self):
        """Stop the AI Employee System."""
        logger.info("Stopping AI Employee System")
        self.running = False

        # Stop autonomous loop
        if self.autonomous_loop:
            self.autonomous_loop.stop()
            logger.info("Autonomous loop stopped")

        # Stop watchers
        if self.inbox_watcher:
            self.inbox_watcher.stop()
            logger.info("Inbox watcher stopped")

        if self.gmail_watcher:
            self.gmail_watcher.stop()
            logger.info("Gmail watcher stopped")

        # Stop scheduler
        if self.scheduler:
            self.scheduler.stop()
            logger.info("Task scheduler stopped")

        logger.info("System shutdown complete")


def main():
    """Main entry point."""
    import argparse

    parser = argparse.ArgumentParser(description="AI Autonomous Employee System - Multi-Tier")
    parser.add_argument(
        "--tier",
        choices=["bronze", "silver", "gold", "platinum"],
        default="platinum",
        help="System tier: bronze (basic), silver (scheduler), gold (cloud+local), platinum (full autonomous)"
    )
    parser.add_argument(
        "--mcp-server",
        action="store_true",
        help="Enable MCP server (silver/platinum only)"
    )
    parser.add_argument(
        "--mode",
        choices=["cloud", "local"],
        help="Agent mode for gold tier (cloud or local)"
    )

    args = parser.parse_args()

    try:
        logger.info(f"Starting {args.tier.upper()} tier system")

        if args.tier == "bronze":
            from tiers.bronze import run
            run()

        elif args.tier == "silver":
            from tiers.silver import run
            run(enable_mcp=args.mcp_server)

        elif args.tier == "gold":
            from tiers.gold import run
            mode = args.mode or "cloud"
            run(mode=mode)

        elif args.tier == "platinum":
            from tiers.platinum import run
            run(enable_mcp=args.mcp_server)

    except Exception as e:
        logger.error(f"Failed to start system: {e}", exc_info=True)
        sys.exit(1)


if __name__ == "__main__":
    main()