Upload 5 files

Implement persistent chat sessions and Word document output: add session sidebar and chat management via DB, generate docx on finalize; update search caching and UI.

app.py

@@ -7,7 +7,24 @@ from generators import generate_course_zip
 from searcher import web_search, fetch_and_extract, get_youtube_transcript
 
 # Bring in DB helpers to persist resources if needed later
-from db import get_resource, upsert_resource, list_resources, new_chat, append_message, load_chat, soft_delete_message
+# Import DB helpers. We include list_chats, rename_chat and delete_chat to support
+# persistent chat sessions and management actions. The resource helpers allow
+# fetching cached resources if needed.
+from db import (
+    get_resource,
+    upsert_resource,
+    list_resources,
+    new_chat,
+    append_message,
+    load_chat,
+    soft_delete_message,
+    list_chats,
+    rename_chat,
+    delete_chat,
+)
+
+# Import the docx utility to generate Word documents for course outlines.
+from docx_utils import outline_to_docx
 
 # System prompt guiding the assistant's behaviour during brainstorming
 SYSTEM_PROMPT = (
@@ -17,8 +34,27 @@ SYSTEM_PROMPT = (
     "conversation and gathered resources."
 )
 
-def chat(user_message, chat_history, chat_pairs, sources, plan, resource_cache):
-    """Handle a user chat message and return updated chat state."""
+def chat(user_message, chat_history, chat_pairs, sources, plan, resource_cache, chat_key):
+    """
+    Handle a user chat message and return updated chat state.
+
+    This version persists messages to the database by inserting user and assistant
+    messages into the `messages` table keyed by `chat_key`. It also returns
+    updated state variables for Gradio to reflect the conversation.
+
+    Args:
+        user_message: The latest user input from the textbox.
+        chat_history: List of message dicts representing the full conversation.
+        chat_pairs: List of (user, assistant) tuples for display in the Chatbot.
+        sources: List of collected resource dicts with 'title' and 'url'.
+        plan: The current course plan text (unused here).
+        resource_cache: Dictionary caching search results by query.
+        chat_key: The unique key identifying the current chat session.
+
+    Returns:
+        Tuple of updated (chat_pairs, chat_history, chat_pairs, sources, plan,
+        resource_cache).
+    """
     # Ensure lists/dicts are initialised
     if chat_history is None:
         chat_history = []
@@ -26,6 +62,13 @@ def chat(user_message, chat_history, chat_pairs, sources, plan, resource_cache):
         chat_pairs = []
     if resource_cache is None:
         resource_cache = {}
+    # Persist the user message to the database if a chat key is provided
+    if chat_key:
+        try:
+            append_message(chat_key, "user", user_message)
+        except Exception:
+            # Ignore DB errors; continue without persistence
+            pass
     # Append the user's message to the conversation history (list of dictionaries for Chatbot)
     chat_history.append({"role": "user", "content": user_message})
     # Build messages including system prompt for API call
@@ -289,6 +332,12 @@ def chat(user_message, chat_history, chat_pairs, sources, plan, resource_cache):
                 )
     # Append assistant reply to conversation history
     chat_history.append({"role": "assistant", "content": assistant_reply})
+    # Persist assistant message to the database
+    if chat_key:
+        try:
+            append_message(chat_key, "assistant", assistant_reply)
+        except Exception:
+            pass
     # Append pair to display history for any other uses (kept for compatibility)
     chat_pairs.append((user_message, assistant_reply))
     # For Chatbot with default type (list of (user, assistant) tuples), return chat_pairs as the first output
@@ -328,7 +377,7 @@ def run_search(query, chat_history, chat_pairs, sources, plan, num_results=5, do
     return summary, chat_history, chat_pairs, sources, plan
 
 def finalize_outline(chat_history, chat_pairs, sources, plan):
-    """Generate a course outline based on the conversation and collected sources."""
+    """Generate a course outline based on the conversation and collected sources (text only)."""
     if chat_history is None:
         chat_history = []
     if sources is None:
@@ -344,6 +393,54 @@ def finalize_outline(chat_history, chat_pairs, sources, plan):
     plan = plan_text
     return plan_text, chat_history, chat_pairs, sources, plan
 
+
+def finalize_and_doc(chat_history, chat_pairs, sources, plan, chat_key):
+    """
+    Generate a course outline and a Word document from the conversation and sources.
+
+    This function calls the planner to create a textual plan, then writes the plan and
+    references to a .docx file using the docx utility. It returns the plan text,
+    updated state variables, and the path to the generated document.
+
+    Args:
+        chat_history: Conversation messages list.
+        chat_pairs: Display pairs list.
+        sources: List of collected resources (dictionaries with title and url).
+        plan: The existing plan text (ignored here).
+        chat_key: The key identifying the current chat (unused here but kept for consistency).
+
+    Returns:
+        Tuple of (plan_text, chat_history, chat_pairs, sources, plan_text, doc_path).
+    """
+    if chat_history is None:
+        chat_history = []
+    if sources is None:
+        sources = []
+    # Generate the course plan text
+    try:
+        plan_text = plan_course(chat_history, sources)
+    except Exception as e:
+        plan_text = (
+            "An error occurred while generating the course outline. Please ensure your API keys are configured.\n"
+            f"(Error: {e})"
+        )
+    # Create a Word document from the plan text and sources
+    try:
+        doc_path = outline_to_docx("Course Outline", plan_text, references=sources)
+    except Exception as e:
+        # If DOCX generation fails, create a temporary text file with an error
+        err_msg = (
+            "An error occurred while creating the Word document.\n"
+            f"(Error: {e})"
+        )
+        tmp_path = "/tmp/outline_error.txt"
+        with open(tmp_path, "w") as f:
+            f.write(err_msg)
+        doc_path = tmp_path
+    # Update plan state
+    plan = plan_text
+    return plan_text, chat_history, chat_pairs, sources, plan, doc_path
+
 def generate_package(plan, sources):
     """Generate the final course package zip file."""
     if plan is None or plan == "":
@@ -369,41 +466,151 @@ def generate_package(plan, sources):
 with gr.Blocks() as demo:
     gr.Markdown(
         """# Course Creator Agent
-Chat with the assistant to brainstorm your course idea. You can ask the assistant to search the internet directly in the chat. When you're ready, click **Finalize Outline** to generate a course plan. Then generate the final course package (ZIP)."""
+Chat with the assistant to brainstorm your course idea. Use the panel on the left to manage multiple chat sessions (create, rename, delete). You can ask the assistant to search the internet directly in the chat. When you're ready, click **Finalize Outline** to generate a course plan and a Word document. Then generate the final course package (ZIP)."""
     )
-    # Chat interface components
-    # Use the default Chatbot type (list of (user, assistant) tuples). This avoids CSS issues with the
-    # messages type and makes the conversation visible without custom styling. Specify a height to
-    # constrain the display area.
-    chatbot = gr.Chatbot(label="Conversation", height=400)
-    msg_input = gr.Textbox(label="Your message", placeholder="Type your message and press Enter", lines=1)
-    # Buttons and outputs (search is triggered via chat; no separate search controls)
-    finalize_btn = gr.Button("Finalize Outline")
-    plan_output = gr.Textbox(label="Course outline", interactive=False)
-    generate_btn = gr.Button("Generate Course Package")
-    file_output = gr.File(label="course.zip")
-    # State variables to keep track of conversation (messages), display pairs, sources and plan
+    # Global states
+    state_chat_key = gr.State(new_chat())
     state_chat_history = gr.State([])
     state_chat_pairs = gr.State([])
     state_sources = gr.State([])
     state_plan = gr.State("")
-    # Cache for previously fetched search results (keyed by lowercased query). Helps prevent
-    # duplicate web searches and ensures all returned resources are real and consistent.
     state_resource_cache = gr.State({})
-    # Handle chat submission: update chatbot display and states
+    
+    # Define layout with a sidebar for sessions and a main panel for chat
+    with gr.Row():
+        with gr.Column(scale=1, min_width=220):
+            session_picker = gr.Radio(label="Your Chats", choices=[], interactive=True)
+            new_chat_btn = gr.Button("New Chat")
+            rename_input = gr.Textbox(label="Rename chat", placeholder="New title", lines=1)
+            rename_btn = gr.Button("Rename")
+            delete_btn = gr.Button("Delete Chat")
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(label="Conversation", height=400)
+            msg_input = gr.Textbox(
+                label="Your message",
+                placeholder="Type your message and press Enter",
+                lines=1,
+            )
+            finalize_btn = gr.Button("Finalize Outline")
+            plan_output = gr.Textbox(label="Course outline", interactive=False)
+            doc_output = gr.File(label="Course outline (Word)")
+            generate_btn = gr.Button("Generate Course Package")
+            file_output = gr.File(label="course.zip")
+
+    # Helper to refresh the sidebar session list. Returns an update for session_picker.
+    def refresh_sessions():
+        chats = list_chats()
+        choices = [c["key"] for c in chats]
+        # Display titles or truncated key if no title
+        labels = [c["title"] if c["title"] else c["key"][:8] for c in chats]
+        # gr.Radio uses choices for values and may display them as-is; set label implicitly via choices
+        return gr.update(choices=choices, value=state_chat_key.value)
+
+    # Load the selected chat into memory and return display pairs/history
+    def load_session(selected_key):
+        if not selected_key:
+            return [], [], [], [], "", {}
+        msgs = load_chat(selected_key)
+        history = []
+        pairs = []
+        buffer = []
+        for msg in msgs:
+            role = msg["role"]
+            content = msg["content"]
+            history.append({"role": role, "content": content})
+            if role == "user":
+                buffer = [content, ""]
+            else:
+                if buffer:
+                    buffer[1] = content
+                    pairs.append(tuple(buffer))
+                    buffer = []
+        return pairs, history, pairs, [], "", {}
+
+    # Create a new chat session and return the new key
+    def handle_new_chat():
+        key = new_chat()
+        return key
+
+    # Rename the current chat session
+    def handle_rename(chat_key, new_title):
+        if chat_key and new_title:
+            rename_chat(chat_key, new_title)
+        return ""
+
+    # Delete the current chat session and return a new key to switch to
+    def handle_delete(chat_key):
+        if chat_key:
+            delete_chat(chat_key)
+        chats = list_chats()
+        if chats:
+            return chats[0]["key"]
+        else:
+            return new_chat()
+
+    # Initialize session list on load
+    demo.load(
+        lambda: refresh_sessions(),
+        None,
+        [session_picker],
+    )
+    # When a session is selected, load it
+    session_picker.change(
+        load_session,
+        inputs=session_picker,
+        outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
+    )
+    # New chat button
+    new_chat_btn.click(
+        handle_new_chat,
+        inputs=None,
+        outputs=state_chat_key,
+    ).then(
+        lambda: refresh_sessions(),
+        None,
+        [session_picker],
+    ).then(
+        load_session,
+        inputs=state_chat_key,
+        outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
+    )
+    # Rename button
+    rename_btn.click(
+        handle_rename,
+        inputs=[state_chat_key, rename_input],
+        outputs=rename_input,
+    ).then(
+        lambda: refresh_sessions(),
+        None,
+        [session_picker],
+    )
+    # Delete button
+    delete_btn.click(
+        handle_delete,
+        inputs=state_chat_key,
+        outputs=state_chat_key,
+    ).then(
+        lambda: refresh_sessions(),
+        None,
+        [session_picker],
+    ).then(
+        load_session,
+        inputs=state_chat_key,
+        outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
+    )
+    # Chat submission: include chat_key for persistence
     msg_input.submit(
         chat,
-        inputs=[msg_input, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
-        # First output goes to the Chatbot; return the updated chat pairs for proper display
+        inputs=[msg_input, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache, state_chat_key],
         outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
     )
-    # Finalize outline button: generate course plan and store it
+    # Finalise outline and produce Word doc
     finalize_btn.click(
-        finalize_outline,
-        inputs=[state_chat_history, state_chat_pairs, state_sources, state_plan],
-        outputs=[plan_output, state_chat_history, state_chat_pairs, state_sources, state_plan],
+        finalize_and_doc,
+        inputs=[state_chat_history, state_chat_pairs, state_sources, state_plan, state_chat_key],
+        outputs=[plan_output, state_chat_history, state_chat_pairs, state_sources, state_plan, doc_output],
     )
-    # Generate course package button
+    # Generate course package (zip)
     generate_btn.click(
         generate_package,
         inputs=[state_plan, state_sources],

db.py

@@ -155,4 +155,56 @@ def load_chat(chat_key: str) -> list[dict]:
 def soft_delete_message(message_id: int) -> None:
     """Mark a message as deleted without removing it."""
     with get_conn() as conn:
-        conn.execute("UPDATE messages SET status='deleted' WHERE id=?", (message_id,))
+        conn.execute("UPDATE messages SET status='deleted' WHERE id=?", (message_id,))
+
+# ---------------------------------------------------------------------------
+# Additional chat management helpers
+#
+# The following functions support listing, renaming, and deleting entire chat
+# sessions. They complement the existing new_chat(), append_message(), and
+# load_chat() functions above. Each chat is keyed by a unique chat_key.
+
+def list_chats(limit: int = 100) -> list[dict]:
+    """Return a list of chat summaries ordered by most recent.
+
+    Args:
+        limit: Maximum number of chats to return.
+
+    Returns:
+        A list of dictionaries with keys 'key', 'title' and 'created_at'.
+    """
+    with get_conn() as conn:
+        rows = conn.execute(
+            "SELECT chat_key, COALESCE(title, 'Untitled'), created_at FROM chats "
+            "ORDER BY created_at DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    return [
+        {"key": chat_key, "title": title, "created_at": created_at}
+        for chat_key, title, created_at in rows
+    ]
+
+
+def rename_chat(chat_key: str, new_title: str) -> None:
+    """Rename a chat session given its key.
+
+    Args:
+        chat_key: The unique key of the chat to rename.
+        new_title: The new title to set.
+    """
+    with get_conn() as conn:
+        conn.execute(
+            "UPDATE chats SET title=? WHERE chat_key=?",
+            (new_title, chat_key),
+        )
+
+
+def delete_chat(chat_key: str) -> None:
+    """Delete a chat session and all its messages.
+
+    Args:
+        chat_key: The unique key of the chat to delete.
+    """
+    with get_conn() as conn:
+        conn.execute("DELETE FROM messages WHERE chat_key=?", (chat_key,))
+        conn.execute("DELETE FROM chats WHERE chat_key=?", (chat_key,))

docx_utils.py

@@ -0,0 +1,90 @@
+"""
+Utility functions for generating Word documents (DOCX) from course outlines.
+
+This module provides a helper to convert a course outline into a .docx file.
+It uses the python-docx library to construct a simple document with a title,
+outline sections, optional bullet points, and a references section. The
+generated file is saved to a temporary location and the path is returned.
+
+Dependencies:
+    python-docx >= 1.1.0
+
+"""
+
+from datetime import datetime
+from typing import List, Dict, Optional
+
+from docx import Document
+from docx.shared import Pt
+
+
+def outline_to_docx(
+    title: str,
+    outline_text: str,
+    references: Optional[List[Dict[str, str]]] = None,
+    path: str = "/tmp/course_outline.docx",
+) -> str:
+    """Create a Word document from a course outline.
+
+    Args:
+        title: Title for the course or outline.
+        outline_text: Plain text of the outline. Each line will be written as a
+            separate paragraph. If you need more structured output, consider
+            extending this function to parse the text.
+        references: Optional list of dictionaries with 'title' and 'url' keys.
+            These will be included in a references section at the end.
+        path: File system path where the document will be written. Defaults
+            to '/tmp/course_outline.docx'.
+
+    Returns:
+        The file path to the generated document.
+    """
+    # Create a new document
+    doc = Document()
+
+    # Title heading
+    title_heading = doc.add_heading(level=1)
+    run = title_heading.add_run(title or "Course Outline")
+    run.bold = True
+    run.font.size = Pt(20)
+
+    # Write each line of the outline as a paragraph
+    for line in (outline_text or "").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # Use list bullet style if the line looks like a bullet (starts with '-' or '*')
+        if line.lstrip().startswith(("-", "*")):
+            # Remove leading bullet characters
+            content = line.lstrip("-* ")
+            p = doc.add_paragraph(content, style="List Bullet")
+        else:
+            p = doc.add_paragraph(line)
+        # Standard font size
+        for r in p.runs:
+            r.font.size = Pt(12)
+
+    # References
+    if references:
+        doc.add_heading("References", level=2)
+        for ref in references:
+            ref_title = ref.get("title", "")
+            ref_url = ref.get("url", "")
+            para = doc.add_paragraph()
+            if ref_title:
+                para.add_run(ref_title).bold = True
+                para.add_run(" — ")
+            para.add_run(ref_url)
+            for r in para.runs:
+                r.font.size = Pt(11)
+
+    # Timestamp
+    doc.add_paragraph()
+    timestamp = datetime.now().strftime("Generated %Y-%m-%d %H:%M:%S")
+    footer = doc.add_paragraph(timestamp)
+    for r in footer.runs:
+        r.font.size = Pt(8)
+
+    # Save document
+    doc.save(path)
+    return path

requirements.txt

@@ -10,4 +10,6 @@ beautifulsoup4>=4.12.0
 
 # Allow the agent to fetch YouTube video transcripts for summarization
 youtube-transcript-api>=1.0.0
+
+# Required to generate Word documents from course outlines
 python-docx>=1.1.0