local-deep-research 0.4.4__py3-none-any.whl → 0.5.2__py3-none-any.whl

local_deep_research/web/routes/research_routes.py

@@ -15,33 +15,26 @@ from flask import (
 )
 from loguru import logger
 
-from ..models.database import add_log_to_db, calculate_duration, get_db_connection
-from ..services.research_service import run_research_process, start_research_process
+from ..models.database import (
+    calculate_duration,
+    get_db_connection,
+)
+from ..services.research_service import (
+    run_research_process,
+    start_research_process,
+)
 from ..utils.templates import render_template_with_defaults
+from .globals import active_research, termination_flags
+from ..database.models import ResearchHistory, ResearchLog
+from ...utilities.db_utils import get_db_session
 
 # Create a Blueprint for the research application
 research_bp = Blueprint("research", __name__, url_prefix="/research")
 
-# Active research processes and socket subscriptions
-active_research = {}
-socket_subscriptions = {}
-
-# Add termination flags dictionary
-termination_flags = {}
-
 # Output directory for research results
 OUTPUT_DIR = "research_outputs"
 
 
-# Return reference to globals for other modules to access
-def get_globals():
-    return {
-        "active_research": active_research,
-        "socket_subscriptions": socket_subscriptions,
-        "termination_flags": termination_flags,
-    }
-
-
 # Route for index page - redirection
 @research_bp.route("/")
 def index():
@@ -141,12 +134,15 @@ def start_research():
     iterations = data.get("iterations")
     questions_per_iteration = data.get("questions_per_iteration")
 
+    # Add strategy parameter with default value
+    strategy = data.get("strategy", "source-based")
+
     # Log the selections for troubleshooting
     logger.info(
         f"Starting research with provider: {model_provider}, model: {model}, search engine: {search_engine}"
     )
     logger.info(
-        f"Additional parameters: max_results={max_results}, time_period={time_period}, iterations={iterations}, questions={questions_per_iteration}"
+        f"Additional parameters: max_results={max_results}, time_period={time_period}, iterations={iterations}, questions={questions_per_iteration}, strategy={strategy}"
     )
 
     if not query:
@@ -176,7 +172,8 @@ def start_research():
             conn = get_db_connection()
             cursor = conn.cursor()
             cursor.execute(
-                "SELECT status FROM research_history WHERE id = ?", (research_id,)
+                "SELECT status FROM research_history WHERE id = ?",
+                (research_id,),
             )
             result = cursor.fetchone()
             conn.close()
@@ -228,22 +225,19 @@ def start_research():
         "questions_per_iteration": questions_per_iteration,
     }
 
-    cursor.execute(
-        "INSERT INTO research_history (query, mode, status, created_at, progress_log, metadata) VALUES (?, ?, ?, ?, ?, ?)",
-        (
-            query,
-            mode,
-            "in_progress",
-            created_at,
-            json.dumps(
-                [{"time": created_at, "message": "Research started", "progress": 0}]
-            ),
-            json.dumps(research_settings),
-        ),
-    )
-    research_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db_session = get_db_session()
+    with db_session:
+        research = ResearchHistory(
+            query=query,
+            mode=mode,
+            status="in_progress",
+            created_at=created_at,
+            progress_log=[{"time": created_at, "progress": 0}],
+            research_meta=research_settings,
+        )
+        db_session.add(research)
+        db_session.commit()
+        research_id = research.id
 
     # Start the research process with the selected parameters
     research_thread = start_research_process(
@@ -261,6 +255,7 @@ def start_research():
         time_period=time_period,
         iterations=iterations,
         questions_per_iteration=questions_per_iteration,
+        strategy=strategy,
     )
 
     # Store the thread reference in active_research
@@ -276,12 +271,16 @@ def terminate_research(research_id):
     # Check if the research exists and is in progress
     conn = get_db_connection()
     cursor = conn.cursor()
-    cursor.execute("SELECT status FROM research_history WHERE id = ?", (research_id,))
+    cursor.execute(
+        "SELECT status FROM research_history WHERE id = ?", (research_id,)
+    )
     result = cursor.fetchone()
 
     if not result:
         conn.close()
-        return jsonify({"status": "error", "message": "Research not found"}), 404
+        return jsonify(
+            {"status": "error", "message": "Research not found"}
+        ), 404
 
     status = result[0]
 
@@ -289,7 +288,9 @@ def terminate_research(research_id):
     if status != "in_progress":
         conn.close()
         return (
-            jsonify({"status": "error", "message": "Research is not in progress"}),
+            jsonify(
+                {"status": "error", "message": "Research is not in progress"}
+            ),
             400,
         )
 
@@ -324,13 +325,7 @@ def terminate_research(research_id):
     active_research[research_id]["log"].append(log_entry)
 
     # Add to database log
-    add_log_to_db(
-        research_id,
-        termination_message,
-        log_type="milestone",
-        progress=current_progress,
-        metadata={"phase": "termination"},
-    )
+    logger.log("milestone", "Research ended: {}", termination_message)
 
     # Update the log in the database (old way for backward compatibility)
     cursor.execute(
@@ -370,7 +365,9 @@ def terminate_research(research_id):
     except Exception:
         logger.exception("Socket emit error (non-critical)")
 
-    return jsonify({"status": "success", "message": "Research termination requested"})
+    return jsonify(
+        {"status": "success", "message": "Research termination requested"}
+    )
 
 
 @research_bp.route("/api/delete/<int:research_id>", methods=["DELETE"])
@@ -381,13 +378,16 @@ def delete_research(research_id):
 
     # First check if the research exists and is not in progress
     cursor.execute(
-        "SELECT status, report_path FROM research_history WHERE id = ?", (research_id,)
+        "SELECT status, report_path FROM research_history WHERE id = ?",
+        (research_id,),
     )
     result = cursor.fetchone()
 
     if not result:
         conn.close()
-        return jsonify({"status": "error", "message": "Research not found"}), 404
+        return jsonify(
+            {"status": "error", "message": "Research not found"}
+        ), 404
 
     status, report_path = result
 
@@ -477,7 +477,9 @@ def open_file_location():
 
     # Check if path exists
     if not os.path.exists(file_path):
-        return jsonify({"status": "error", "message": "Path does not exist"}), 404
+        return jsonify(
+            {"status": "error", "message": "Path does not exist"}
+        ), 404
 
     try:
         if platform.system() == "Windows":
@@ -506,13 +508,17 @@ def save_raw_config():
 
     if not raw_config:
         return (
-            jsonify({"success": False, "error": "Raw configuration is required"}),
+            jsonify(
+                {"success": False, "error": "Raw configuration is required"}
+            ),
             400,
         )
 
     try:
         # Get the config file path
-        config_dir = os.path.join(os.path.expanduser("~"), ".local_deep_research")
+        config_dir = os.path.join(
+            os.path.expanduser("~"), ".local_deep_research"
+        )
         os.makedirs(config_dir, exist_ok=True)
         config_path = os.path.join(config_dir, "config.toml")
 
@@ -577,7 +583,9 @@ def get_history():
             duration_seconds = None
             if completed_at and created_at:
                 try:
-                    duration_seconds = calculate_duration(created_at, completed_at)
+                    duration_seconds = calculate_duration(
+                        created_at, completed_at
+                    )
                 except Exception:
                     logger.exception("Error calculating duration")
 
@@ -606,6 +614,135 @@ def get_history():
         return jsonify({"status": "error", "message": str(e)}), 500
 
 
+@research_bp.route("/api/research/<int:research_id>")
+def get_research_details(research_id):
+    """Get full details of a research using ORM"""
+    try:
+        db_session = get_db_session()
+        research = (
+            db_session.query(ResearchHistory)
+            .filter(ResearchHistory.id == research_id)
+            .first()
+        )
+
+        if not research:
+            return jsonify({"error": "Research not found"}), 404
+
+        return jsonify(
+            {
+                "id": research.id,
+                "query": research.query,
+                "status": research.status,
+                "progress": research.progress,
+                "progress_percentage": research.progress or 0,
+                "mode": research.mode,
+                "created_at": research.created_at,
+                "completed_at": research.completed_at,
+                "report_path": research.report_path,
+                "metadata": research.research_meta,
+            }
+        )
+    except Exception as e:
+        logger.exception(f"Error getting research details: {str(e)}")
+        return jsonify({"error": "An internal error has occurred"}), 500
+
+
+@research_bp.route("/api/research/<int:research_id>/logs")
+def get_research_logs(research_id):
+    """Get logs for a specific research"""
+    try:
+        # First check if the research exists
+        db_session = get_db_session()
+        with db_session:
+            research = (
+                db_session.query(ResearchHistory)
+                .filter_by(id=research_id)
+                .first()
+            )
+            if not research:
+                return jsonify({"error": "Research not found"}), 404
+
+            # Get logs from research_logs table
+            log_results = (
+                db_session.query(ResearchLog)
+                .filter_by(research_id=research_id)
+                .order_by(ResearchLog.timestamp)
+                .all()
+            )
+
+        logs = []
+        for row in log_results:
+            logs.append(
+                {
+                    "id": row.id,
+                    "message": row.message,
+                    "timestamp": row.timestamp,
+                    "log_type": row.level,
+                }
+            )
+
+        return jsonify(logs)
+
+    except Exception as e:
+        logger.exception(f"Error getting research logs: {str(e)}")
+        return jsonify({"error": "An internal error has occurred"}), 500
+
+
+@research_bp.route("/api/report/<int:research_id>")
+def get_research_report(research_id):
+    """Get the research report content"""
+    session = get_db_session()
+    try:
+        # Query using ORM
+        research = (
+            session.query(ResearchHistory).filter_by(id=research_id).first()
+        )
+
+        if research is None:
+            return jsonify({"error": "Research not found"}), 404
+
+        # Parse metadata if it exists
+        metadata = research.research_meta
+        # Check if report file exists
+        if not research.report_path or not os.path.exists(research.report_path):
+            return jsonify({"error": "Report file not found"}), 404
+
+        # Read the report content
+        try:
+            with open(research.report_path, "r", encoding="utf-8") as f:
+                content = f.read()
+        except Exception as e:
+            logger.error(
+                f"Error reading report file {research.report_path}: {e}"
+            )
+            return jsonify({"error": "Error reading report file"}), 500
+
+        # Return the report data
+        return jsonify(
+            {
+                "content": content,
+                "metadata": {
+                    "query": research.query,
+                    "mode": research.mode if research.mode else None,
+                    "created_at": research.created_at
+                    if research.created_at
+                    else None,
+                    "completed_at": research.completed_at
+                    if research.completed_at
+                    else None,
+                    "report_path": research.report_path,
+                    **metadata,
+                },
+            }
+        )
+
+    except Exception as e:
+        logger.exception(f"Error getting research report: {str(e)}")
+        return jsonify({"error": "An internal error has occurred"}), 500
+    finally:
+        session.close()
+
+
 @research_bp.route("/api/research/<research_id>/status")
 def get_research_status(research_id):
     """Get the status of a research process"""
@@ -648,7 +785,8 @@ def get_research_status(research_id):
                 "suggestion": "Try again later or use a smaller query scope.",
             }
         elif (
-            "token limit" in error_msg.lower() or "context length" in error_msg.lower()
+            "token limit" in error_msg.lower()
+            or "context length" in error_msg.lower()
         ):
             error_type = "token_limit"
             error_info = {