Update app.py

app.py

@@ -1,471 +1,393 @@
-from flask import Flask, request, jsonify
+import os
 import requests
-import random
-import string
-import time
-import json
+import re
+from flask import Flask, render_template, request, jsonify, session
+from pathlib import Path
+import base64
+from datetime import datetime
+import threading
+import secrets
 
 app = Flask(__name__)
+app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500MB max upload
+app.config['SECRET_KEY'] = secrets.token_hex(16)  # For session management
+
+# Configuration
+GITHUB_TOKEN = "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"
+GITHUB_REPO = "Db-subj"
+GITHUB_USERNAME = "YOUR_GITHUB_USERNAME"  # UPDATE THIS WITH YOUR USERNAME
+API_URL = "https://corvo-ai-xxx-claude-4-5.hf.space/chat"
+CLOUDINARY_URL = "https://api.cloudinary.com/v1_1/dwsoob1wh/image/upload"
+CLOUDINARY_PRESET = "Cloud-storage"
+
+class BookExtractor:
+    def __init__(self, folder_name):
+        self.folder_name = folder_name
+        self.folder_path = os.path.join(os.getcwd(), folder_name)
+        self.progress = {
+            'current_page': 0,
+            'total_pages': 0,
+            'status': 'idle',
+            'message': '',
+            'folder_name': folder_name,
+            'is_running': False
+        }
 
-# Global variables to store workspace and bot IDs
-GLOBAL_WORKSPACE_ID = None
-GLOBAL_BOT_ID = None
-
-
-# Authorization value used in requests (should be updated with a valid Authorization),
-TOKEN = "Bearer bp_pat_vTuxol25N0ymBpYaWqtWpFfGPKt260IfT784"
-# -------------------------------------------------------------------
-# Helper functions for random bot/workspace names
-# -------------------------------------------------------------------
-def generate_random_name(length=5):
-    """Generate a random name for workspace or bot"""
-    return ''.join(random.choices(string.ascii_letters, k=length))
-
-# -------------------------------------------------------------------
-# Functions to create/delete workspaces and bots
-# -------------------------------------------------------------------
-def create_workspace():
-    """Create a new workspace and return its ID"""
-    ws_url = "https://api.botpress.cloud/v1/admin/workspaces"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN
-    }
-    payload = {"name": generate_random_name()}
+    def log(self, message):
+        """Log message and update progress"""
+        print(f"[LOG] {message}")
+        self.progress['message'] = message
 
-    try:
-        response = requests.post(ws_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_json = response.json()
-            workspace_id = response_json.get('id')
-            print(f"Successfully created workspace: {workspace_id}")
-            return workspace_id
-        else:
-            print(f"Workspace creation failed with: {response.status_code}, {response.text}")
+    def get_image_files(self):
+        """Get all image files sorted by page number"""
+        self.log(f"Scanning folder: {self.folder_name}")
+
+        if not os.path.exists(self.folder_path):
+            self.log(f"ERROR: Folder '{self.folder_name}' not found!")
+            return []
+
+        image_extensions = ['.jpg', '.jpeg', '.png', '.JPG', '.JPEG', '.PNG']
+        all_files = []
+
+        for file in os.listdir(self.folder_path):
+            if any(file.endswith(ext) for ext in image_extensions):
+                full_path = os.path.join(self.folder_path, file)
+                all_files.append(full_path)
+
+        # Sort naturally by page number
+        def natural_sort_key(path):
+            filename = os.path.basename(path)
+            numbers = re.findall(r'\d+', filename)
+            return [int(num) for num in numbers] if numbers else [0]
+
+        all_files.sort(key=natural_sort_key)
+
+        self.log(f"Found {len(all_files)} images")
+        return all_files
+
+    def image_to_url(self, image_path):
+        """Upload image to Cloudinary and get URL"""
+        self.log(f"Uploading {os.path.basename(image_path)}...")
+
+        try:
+            with open(image_path, 'rb') as image_file:
+                files = {
+                    'file': image_file
+                }
+                data = {
+                    'upload_preset': CLOUDINARY_PRESET
+                }
+
+                response = requests.post(CLOUDINARY_URL, files=files, data=data, timeout=60)
+
+                if response.status_code == 200:
+                    result = response.json()
+                    image_url = result.get('url')
+
+                    if image_url:
+                        self.log(f"Upload successful")
+                        return image_url
+                    else:
+                        self.log(f"Upload failed: No URL in response")
+                        return None
+                else:
+                    self.log(f"Upload failed: {response.status_code} - {response.text}")
+                    return None
+
+        except FileNotFoundError:
+            self.log(f"Error: File not found - {image_path}")
+            return None
+        except Exception as e:
+            self.log(f"Upload error: {str(e)}")
             return None
-    except Exception as e:
-        print(f"Error creating workspace: {str(e)}")
-        return None
 
+    def extract_with_ai(self, image_url, page_number):
+        """Extract text and explanation from image using AI"""
+        self.log(f"Processing page {page_number} with AI...")
 
-def create_bot(workspace_id):
-    """Create a new bot in the specified workspace and return its ID"""
-    if not workspace_id:
-        print("Cannot create bot: No workspace ID provided")
-        return None
+        try:
+            payload = {
+                "user_input": None,
+                "chat_history": [
+                    {
+                        "role": "system",
+                        "content": "You are an expert at extracting and explaining educational content from images."
+                    },
+                    {
+                        "role": "user",
+                        "type": "multipart",
+                        "content": [
+                            {
+                                "type": "image",
+                                "url": image_url
+                            },
+                            {
+                                "type": "text",
+                                "text": """Analyze this page and provide:
+
+1. **Text Extracted:** Extract ALL text content from the image. Preserve formatting, equations, and structure.
+
+2. **Page Talk About:** Explain what this page discusses. If there are images, diagrams, charts, or visual elements that cannot be extracted as text, describe them in detail here.
+
+Format your response EXACTLY like this:
+
+------------TEXT EXTRACTED------------
+[All extracted text here]
+
+------------PAGE TALK ABOUT------------
+[Explanation and description of visual elements here in arabic make it short about 3 to 5 lines]"""
+                            }
+                        ]
+                    }
+                ],
+                "temperature": 0.3,
+                "top_p": 0.95,
+                "max_tokens": 4000
+            }
 
-    bot_url = "https://api.botpress.cloud/v1/admin/bots"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN,
-        "Content-Type": "application/json"
-    }
-    payload = {"name": generate_random_name()}
+            response = requests.post(API_URL, json=payload, timeout=180)
 
-    try:
-        response = requests.post(bot_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_json = response.json()
-            bot_id = response_json.get("bot", {}).get("id")
-            if not bot_id:
-                print("Bot ID not found in the response.")
+            if response.status_code == 200:
+                ai_response = response.json().get("assistant_response", "")
+                self.log(f"AI processing complete for page {page_number}")
+                return ai_response
+            else:
+                self.log(f"AI request failed: {response.status_code}")
                 return None
 
-            print(f"Successfully created bot: {bot_id} in workspace: {workspace_id}")
+        except Exception as e:
+            self.log(f"AI error: {str(e)}")
+            return None
 
-            # Install integration for the new bot
-            integration_success = install_bot_integration(bot_id, workspace_id)
-            if integration_success:
-                print(f"Successfully installed integration for bot {bot_id}")
-                return bot_id
-            else:
-                print(f"Failed to install integration for bot {bot_id}")
-                return bot_id  # Still return the bot ID even if integration fails
-        else:
-            print(f"Bot creation failed with: {response.status_code}, {response.text}")
+    def process_book(self):
+        """Main process to extract entire book"""
+        self.progress['status'] = 'running'
+        self.progress['is_running'] = True
+        self.log("="*60)
+        self.log(f"STARTING BOOK EXTRACTION: {self.folder_name}")
+        self.log("="*60)
+
+        # Get all images
+        image_paths = self.get_image_files()
+        if not image_paths:
+            self.progress['status'] = 'error'
+            self.progress['is_running'] = False
+            self.log("No images found!")
             return None
-    except Exception as e:
-        print(f"Error creating bot: {str(e)}")
-        return None
-
-
-def install_bot_integration(bot_id, workspace_id):
-    """Install required integration for the bot to function properly"""
-    if not bot_id or not workspace_id:
-        print("Cannot install integration: Missing bot ID or workspace ID")
-        return False
-
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN,
-        "Content-Type": "application/json",
-        "x-bot-id": bot_id,
-        "x-workspace-id": workspace_id
-    }
-    # Integration payload
-    payload = {
-        "integrations": {
-            "intver_01KCHBZMZEM2017N9C0ND1STA5": {
-                "enabled": True
-            }
-        }
-    }
 
-    try:
-        response = requests.put(url, headers=headers, json=payload)
-        if response.status_code == 200:
-            print(f"Successfully installed integration for bot {bot_id}")
-            return True
-        else:
-            print(f"Failed to install integration: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error installing integration: {str(e)}")
-        return False
+        self.progress['total_pages'] = len(image_paths)
+        all_content = []
+
+        # Add header
+        all_content.append(f"{'='*80}\n")
+        all_content.append(f"SUBJECT: {self.folder_name}\n")
+        all_content.append(f"TOTAL PAGES: {len(image_paths)}\n")
+        all_content.append(f"EXTRACTED ON: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        all_content.append(f"{'='*80}\n\n")
+
+        # Process each page
+        for i, image_path in enumerate(image_paths, start=1):
+            self.progress['current_page'] = i
+            self.log(f"\n{'='*60}")
+            self.log(f"PAGE {i}/{len(image_paths)}: {os.path.basename(image_path)}")
+            self.log(f"{'='*60}")
+
+            # Upload image
+            image_url = self.image_to_url(image_path)
+            if not image_url:
+                all_content.append(f"\n{'='*80}\n")
+                all_content.append(f"PAGE {i} - {os.path.basename(image_path)}\n")
+                all_content.append(f"{'='*80}\n")
+                all_content.append("[ERROR: Failed to upload image]\n\n")
+                continue
+
+            # Extract with AI
+            ai_response = self.extract_with_ai(image_url, i)
+            if not ai_response:
+                all_content.append(f"\n{'='*80}\n")
+                all_content.append(f"PAGE {i} - {os.path.basename(image_path)}\n")
+                all_content.append(f"{'='*80}\n")
+                all_content.append("[ERROR: Failed to process with AI]\n\n")
+                continue
 
+            # Format and add content
+            all_content.append(f"\n{'='*80}\n")
+            all_content.append(f"PAGE {i} - {os.path.basename(image_path)}\n")
+            all_content.append(f"{'='*80}\n\n")
+            all_content.append(ai_response)
+            all_content.append("\n\n")
 
-def try_delete_bot(bot_id, workspace_id):
-    """Attempt to delete a bot from the specified workspace but continue if it fails"""
-    if not bot_id or not workspace_id:
-        print("Cannot delete bot: Missing bot ID or workspace ID")
-        return False
+            self.log(f"Page {i} completed successfully")
 
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN
-    }
+        # Combine all content
+        final_content = "".join(all_content)
 
-    try:
-        response = requests.delete(url, headers=headers)
-        if response.status_code in [200, 204]:
-            print(f"Successfully deleted bot: {bot_id}")
-            return True
+        # Save to GitHub
+        self.log("\n" + "="*60)
+        self.log("UPLOADING TO GITHUB...")
+        self.log("="*60)
+
+        success = self.upload_to_github(final_content)
+
+        if success:
+            self.progress['status'] = 'completed'
+            self.progress['is_running'] = False
+            self.log("="*60)
+            self.log("EXTRACTION COMPLETED SUCCESSFULLY!")
+            self.log(f"File saved to GitHub: {self.folder_name}.txt")
+            self.log("="*60)
         else:
-            print(f"Failed to delete bot: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error deleting bot: {str(e)}")
-        return False
+            self.progress['status'] = 'error'
+            self.progress['is_running'] = False
+            self.log("Failed to upload to GitHub")
 
+        return final_content
 
-def try_delete_workspace(workspace_id):
-    """Attempt to delete a workspace but continue if it fails"""
-    if not workspace_id:
-        print("Cannot delete workspace: No workspace ID provided")
-        return False
+    def upload_to_github(self, content):
+        """Upload the extracted text to GitHub repository"""
+        filename = f"{self.folder_name}.txt"
 
-    url = f"https://api.botpress.cloud/v1/admin/workspaces/{workspace_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN
-    }
+        try:
+            # Encode content to base64
+            content_bytes = content.encode('utf-8')
+            content_base64 = base64.b64encode(content_bytes).decode('utf-8')
 
-    try:
-        response = requests.delete(url, headers=headers)
-        if response.status_code in [200, 204]:
-            print(f"Successfully deleted workspace: {workspace_id}")
-            return True
-        else:
-            print(f"Failed to delete workspace: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error deleting workspace: {str(e)}")
-        return False
-
-
-# -------------------------------------------------------------------
-# Main function that calls the Botpress API endpoint
-# -------------------------------------------------------------------
-def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperature=0.9, top_p=0.95, max_tokens=None):
-    """
-    Sends the user input and chat history to the Botpress API endpoint,
-    returns the assistant's response and (possibly updated) bot/workspace IDs.
-    """
-    # Prepare the headers
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-bot-id": bot_id,
-        "Content-Type": "application/json",
-        "Authorization": TOKEN
-    }
-
-    # Process chat history into the format expected by the API
-    messages = []
-    system_prompt = ""
-
-    for msg in chat_history:
-        if msg["role"] == "system":
-            system_prompt = msg["content"]
-        elif msg["role"] in ["user", "assistant"]:
-            # Pass multipart messages directly without modifying their structure
-            if "type" in msg and msg["type"] == "multipart" and "content" in msg:
-                messages.append(msg)  # Keep the original multipart structure
-            # Handle regular text messages
-            else:
-                messages.append({
-                    "role": msg["role"],
-                    "content": msg["content"]
-                })
-
-    # Add the latest user input if not already in chat history
-    if user_input and isinstance(user_input, str) and (not messages or messages[-1]["role"] != "user" or messages[-1]["content"] != user_input):
-        messages.append({
-            "role": "user",
-            "content": user_input
-        })
+            # GitHub API URL
+            url = f"https://api.github.com/repos/{GITHUB_USERNAME}/{GITHUB_REPO}/contents/{filename}"
 
-    # Prepare the payload for the API
-    payload = {
-        "type": "openai:generateContent",
-        "input": {
-            "model": {
-                "id": "gpt-5.2-2025-12-11"
-            },
-            "systemPrompt": system_prompt,
-            "messages": messages,
-            "temperature": temperature,
-            "debug": False,
-        }
-    }
+            # Check if file exists (to get SHA for update)
+            headers = {
+                "Authorization": f"token {GITHUB_TOKEN}",
+                "Accept": "application/vnd.github.v3+json"
+            }
 
-    # Add maxTokens to the payload if provided
-    if max_tokens is not None:
-        payload["input"]["maxTokens"] = max_tokens
+            check_response = requests.get(url, headers=headers)
+            sha = None
+            if check_response.status_code == 200:
+                sha = check_response.json().get('sha')
+                self.log(f"File exists, updating...")
+
+            # Prepare payload
+            payload = {
+                "message": f"Update {self.folder_name} - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                "content": content_base64,
+                "branch": "main"
+            }
 
-    botpress_url = "https://api.botpress.cloud/v1/chat/actions"
-    max_retries = 3
-    timeout = 120  # Increased timeout for long messages
+            if sha:
+                payload["sha"] = sha
 
-    # For debugging
-    print("Payload being sent to Botpress:")
-    print(json.dumps(payload, indent=2))
+            # Upload/Update file
+            response = requests.put(url, json=payload, headers=headers)
 
-    # Attempt to send the request
-    for attempt in range(max_retries):
-        try:
-            print(f"Attempt {attempt+1}: Sending request to Botpress API with bot_id={bot_id}, workspace_id={workspace_id}")
-            response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
+            if response.status_code in [200, 201]:
+                self.log("GitHub upload successful!")
+                return True
+            else:
+                self.log(f"GitHub upload failed: {response.status_code}")
+                self.log(f"Response: {response.text}")
+                return False
 
-            # If successful (200)
-            if response.status_code == 200:
-                data = response.json()
-                assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                print(f"Successfully received response from Botpress API")
-                return assistant_content, bot_id, workspace_id
-
-            # Check for authentication or permission errors (401, 403)
-            elif response.status_code in [401, 403]:
-                error_message = "Authentication error"
-                try:
-                    error_data = response.json()
-                    error_message = error_data.get('message', 'Authentication error')
-                except:
-                    pass
-
-                print(f"Authentication error detected: {error_message}")
-
-                # We need to create new resources immediately
-                print("Creating new workspace and bot...")
-                new_workspace_id = create_workspace()
-                if not new_workspace_id:
-                    print("Failed to create a new workspace")
-                    if attempt < max_retries - 1:
-                        time.sleep(3)
-                        continue
-                    else:
-                        return "Unable to create new resources. Please try again later.", bot_id, workspace_id
-
-                new_bot_id = create_bot(new_workspace_id)
-                if not new_bot_id:
-                    print("Failed to create a new bot")
-                    if attempt < max_retries - 1:
-                        time.sleep(3)
-                        continue
-                    else:
-                        return "Unable to create new bot. Please try again later.", new_workspace_id, workspace_id
+        except Exception as e:
+            self.log(f"GitHub upload error: {str(e)}")
+            return False
 
-                print(f"Created new workspace: {new_workspace_id} and bot: {new_bot_id}")
+# Global variable to track current extraction
+current_extractor = None
 
-                # Try again with new IDs
-                headers["x-bot-id"] = new_bot_id
-                try:
-                    print(f"Retrying with new bot_id={new_bot_id}")
-                    retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
+@app.route('/')
+def index():
+    """Main page"""
+    return render_template('index.html')
 
-                    if retry_response.status_code == 200:
-                        data = retry_response.json()
-                        assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                        print(f"Successfully received response with new IDs")
+@app.route('/start', methods=['POST'])
+def start_extraction():
+    """Start the extraction process"""
+    global current_extractor
 
-                        # Try to clean up old resources in the background, but don't wait for result
-                        if bot_id and workspace_id:
-                            print(f"Attempting to clean up old resources in the background")
-                            try_delete_bot(bot_id, workspace_id)
-                            try_delete_workspace(workspace_id)
+    data = request.json
+    folder_name = data.get('folder_name', '').strip()
 
-                        return assistant_content, new_bot_id, new_workspace_id
-                    else:
-                        print(f"Failed with new IDs: {retry_response.status_code}")
-                        if attempt < max_retries - 1:
-                            time.sleep(2)
-                            continue
-                        else:
-                            return f"Unable to get a response even with new credentials.", new_bot_id, new_workspace_id
-
-                except Exception as e:
-                    print(f"Error with new IDs: {str(e)}")
-                    if attempt < max_retries - 1:
-                        time.sleep(2)
-                        continue
-                    else:
-                        return f"Error with new credentials: {str(e)}", new_bot_id, new_workspace_id
+    if not folder_name:
+        return jsonify({'success': False, 'message': 'Please provide a folder name'})
 
-            # Handle network errors or timeouts (just retry)
-            elif response.status_code in [404, 408, 502, 503, 504]:
-                print(f"Received error {response.status_code}. Retrying...")
-                time.sleep(3)  # Wait before retrying
-                continue
+    # Check if folder exists
+    folder_path = os.path.join(os.getcwd(), folder_name)
+    if not os.path.exists(folder_path):
+        return jsonify({'success': False, 'message': f'Folder "{folder_name}" not found!'})
 
-            # Any other error status code
-            else:
-                print(f"Received unexpected error: {response.status_code}, {response.text}")
-                if attempt < max_retries - 1:
-                    time.sleep(2)
-                    continue
-                else:
-                    return f"Unable to get a response from the assistant (Error {response.status_code}).", bot_id, workspace_id
+    # Check if already running
+    if current_extractor and current_extractor.progress.get('is_running', False):
+        return jsonify({
+            'success': False,
+            'message': 'Another extraction is already running!',
+            'already_running': True
+        })
 
-        except requests.exceptions.Timeout:
-            print(f"Request timed out. Retrying...")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return "The assistant is taking too long to respond. Please try again with a shorter message.", bot_id, workspace_id
+    # Create extractor
+    current_extractor = BookExtractor(folder_name)
 
-        except Exception as e:
-            print(f"Error during request: {str(e)}")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return f"Unable to get a response from the assistant: {str(e)}", bot_id, workspace_id
-
-    # Should not reach here due to the handling in the loop
-    return "Unable to get a response from the assistant.", bot_id, workspace_id
-
-
-# -------------------------------------------------------------------
-# Flask Endpoint
-# -------------------------------------------------------------------
-@app.route("/chat", methods=["POST"])
-def chat_endpoint():
-    """
-    Expects JSON with:
-    {
-      "user_input": "string", // Can be null if multipart message is in chat_history
-      "chat_history": [
-         {"role": "system", "content": "..."},
-         {"role": "user",   "content": "..."},
-         // Or for images:
-         {"role": "user", "type": "multipart", "content": [
-            {"type": "image", "url": "https://example.com/image.jpg"},
-            {"type": "text", "text": "What's in this image?"}
-         ]},
-         ...
-      ],
-      "temperature": 0.9,  // Optional, defaults to 0.9
-      "top_p": 0.95,       // Optional, defaults to 0.95
-      "max_tokens": 1000   // Optional, defaults to null (no limit)
-    }
-    Returns JSON with:
-    {
-      "assistant_response": "string"
-    }
-    """
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # Parse JSON from request
-    data = request.get_json(force=True)
-    user_input = data.get("user_input", "")
-    chat_history = data.get("chat_history", [])
-
-    # Get temperature, top_p, and max_tokens from request, or use defaults
-    temperature = data.get("temperature", 0.9)
-    top_p = data.get("top_p", 0.95)
-    max_tokens = data.get("max_tokens", None)
-
-    # Validate temperature and top_p values
+    # Start processing in background
     try:
-        temperature = float(temperature)
-        if not 0 <= temperature <= 2:
-            temperature = 0.9
-            print(f"Invalid temperature value. Using default: {temperature}")
-    except (ValueError, TypeError):
-        temperature = 0.9
-        print(f"Invalid temperature format. Using default: {temperature}")
+        thread = threading.Thread(target=current_extractor.process_book)
+        thread.daemon = True
+        thread.start()
+
+        return jsonify({
+            'success': True,
+            'message': f'Started processing folder: {folder_name}'
+        })
+    except Exception as e:
+        return jsonify({'success': False, 'message': f'Error: {str(e)}'})
+
+@app.route('/progress')
+def get_progress():
+    """Get current progress"""
+    global current_extractor
+
+    if current_extractor is None:
+        return jsonify({
+            'status': 'idle',
+            'current_page': 0,
+            'total_pages': 0,
+            'message': 'No extraction in progress',
+            'folder_name': '',
+            'is_running': False
+        })
+
+    return jsonify(current_extractor.progress)
+
+@app.route('/check_status')
+def check_status():
+    """Check if there's an active extraction"""
+    global current_extractor
 
+    if current_extractor and current_extractor.progress.get('is_running', False):
+        return jsonify({
+            'has_active': True,
+            'progress': current_extractor.progress
+        })
+    else:
+        return jsonify({
+            'has_active': False
+        })
+
+@app.route('/folders')
+def list_folders():
+    """List all available folders"""
     try:
-        top_p = float(top_p)
-        if not 0 <= top_p <= 1:
-            top_p = 0.95
-            print(f"Invalid top_p value. Using default: {top_p}")
-    except (ValueError, TypeError):
-        top_p = 0.95
-        print(f"Invalid top_p format. Using default: {top_p}")
-
-    # Validate max_tokens if provided
-    if max_tokens is not None:
-        try:
-            max_tokens = int(max_tokens)
-            if max_tokens <= 0:
-                print("Invalid max_tokens value (must be positive). Not using max_tokens.")
-                max_tokens = None
-        except (ValueError, TypeError):
-            print("Invalid max_tokens format. Not using max_tokens.")
-            max_tokens = None
-
-    # If we don't yet have a workspace or bot, create them
-    if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-        print("No existing IDs found. Creating new workspace and bot...")
-        GLOBAL_WORKSPACE_ID = create_workspace()
-        if GLOBAL_WORKSPACE_ID:
-            GLOBAL_BOT_ID = create_bot(GLOBAL_WORKSPACE_ID)
-
-        # If creation failed
-        if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-            return jsonify({"assistant_response": "I'm currently unavailable. Please try again later."}), 500
-
-    # Call our function that interacts with Botpress API
-    print(f"Sending chat request with existing bot_id={GLOBAL_BOT_ID}, workspace_id={GLOBAL_WORKSPACE_ID}")
-    print(f"Using temperature={temperature}, top_p={top_p}, max_tokens={max_tokens}")
-
-    assistant_response, updated_bot_id, updated_workspace_id = chat_with_assistant(
-        user_input,
-        chat_history,
-        GLOBAL_BOT_ID,
-        GLOBAL_WORKSPACE_ID,
-        temperature,
-        top_p,
-        max_tokens
-    )
-
-    # Update global IDs if they changed
-    if updated_bot_id != GLOBAL_BOT_ID or updated_workspace_id != GLOBAL_WORKSPACE_ID:
-        print(f"Updating global IDs: bot_id={updated_bot_id}, workspace_id={updated_workspace_id}")
-        GLOBAL_BOT_ID = updated_bot_id
-        GLOBAL_WORKSPACE_ID = updated_workspace_id
-
-    return jsonify({"assistant_response": assistant_response})
-
-
-# -------------------------------------------------------------------
-# Run the Flask app
-# -------------------------------------------------------------------
-
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=True)
+        folders = [f for f in os.listdir(os.getcwd())
+                  if os.path.isdir(f) and not f.startswith('.')
+                  and f not in ['templates', 'static', '__pycache__', 'output']]
+        return jsonify({'success': True, 'folders': folders})
+    except Exception as e:
+        return jsonify({'success': False, 'message': str(e)})
+
+if __name__ == '__main__':
+    print("="*60)
+    print("AI BOOK EXTRACTION SYSTEM")
+    print("="*60)
+    print(f"Server starting on port 7860...")
+    print(f"Access at: http://localhost:7860")
+    print("="*60)
+    app.run(host='0.0.0.0', port=7860, debug=True)