Upload folder using huggingface_hub

ankigen_core/agents/integration.py

@@ -52,71 +52,58 @@ class AgentOrchestrator:
         library_name: Optional[str] = None,
         library_topic: Optional[str] = None,
         generate_cloze: bool = False,
+        topics_list: Optional[List[str]] = None,
+        cards_per_topic: int = 8,
     ) -> Tuple[List[Card], Dict[str, Any]]:
-        """Generate cards using the agent system"""
+        """Generate cards using the agent system.
+
+        If topics_list is provided, generates cards for each subtopic separately
+        to ensure comprehensive coverage. Otherwise falls back to single-topic mode.
+        """
         start_time = datetime.now()
 
         try:
             if not self.openai_client:
                 raise ValueError("Agent system not initialized")
 
-            logger.info(f"Starting agent-based card generation: {topic} ({subject})")
-
             # Enhance context with library documentation if requested
             enhanced_context = context or {}
             library_docs = None
 
             if library_name:
-                logger.info(f"Fetching library documentation for: {library_name}")
-                try:
-                    context7_client = Context7Client()
-
-                    # Dynamic token allocation based on card generation needs
-                    # More cards need more thorough documentation
-                    base_tokens = 8000  # Increased base from 5000
-                    if num_cards > 40:
-                        token_limit = 12000  # Large card sets need more context
-                    elif num_cards > 20:
-                        token_limit = 10000  # Medium sets
-                    else:
-                        token_limit = base_tokens  # Small sets
-
-                    # If topic is specified, we can be more focused and use fewer tokens
-                    if library_topic:
-                        token_limit = int(
-                            token_limit * 0.8
-                        )  # Can be more efficient with focused retrieval
-
-                    logger.info(
-                        f"Fetching {token_limit} tokens of documentation"
-                        + (f" for topic: {library_topic}" if library_topic else "")
-                    )
-
-                    library_docs = await context7_client.fetch_library_documentation(
-                        library_name, topic=library_topic, tokens=token_limit
-                    )
-
-                    if library_docs:
-                        enhanced_context["library_documentation"] = library_docs
-                        enhanced_context["library_name"] = library_name
-                        logger.info(
-                            f"Added {len(library_docs)} chars of {library_name} documentation to context"
-                        )
-                    else:
-                        logger.warning(
-                            f"Could not fetch documentation for library: {library_name}"
-                        )
-                except Exception as e:
-                    logger.error(f"Error fetching library documentation: {e}")
-
-            cards = await self._generation_phase(
-                topic=topic,
-                subject=subject,
-                num_cards=num_cards,
-                difficulty=difficulty,
-                context=enhanced_context,
-                generate_cloze=generate_cloze,
-            )
+                library_docs = await self._fetch_library_docs(
+                    library_name, library_topic, num_cards
+                )
+                if library_docs:
+                    enhanced_context["library_documentation"] = library_docs
+                    enhanced_context["library_name"] = library_name
+
+            # Generate cards - either per-topic or single-topic mode
+            if topics_list and len(topics_list) > 0:
+                logger.info(
+                    f"Starting multi-topic generation: {len(topics_list)} topics, "
+                    f"{cards_per_topic} cards each for '{topic}'"
+                )
+                cards = await self._generate_cards_per_topic(
+                    main_subject=topic,
+                    subject=subject,
+                    topics_list=topics_list,
+                    cards_per_topic=cards_per_topic,
+                    difficulty=difficulty,
+                    context=enhanced_context,
+                    generate_cloze=generate_cloze,
+                )
+            else:
+                # Fallback to single-topic mode
+                logger.info(f"Starting single-topic generation: {topic} ({subject})")
+                cards = await self._generation_phase(
+                    topic=topic,
+                    subject=subject,
+                    num_cards=num_cards,
+                    difficulty=difficulty,
+                    context=enhanced_context,
+                    generate_cloze=generate_cloze,
+                )
 
             # Collect metadata
             metadata = {
@@ -128,6 +115,8 @@ class AgentOrchestrator:
                 "difficulty": difficulty,
                 "library_name": library_name if library_name else None,
                 "library_docs_used": bool(library_docs),
+                "topics_list": topics_list,
+                "multi_topic_mode": topics_list is not None and len(topics_list) > 0,
             }
 
             logger.info(
@@ -139,6 +128,96 @@ class AgentOrchestrator:
             logger.error(f"Agent-based generation failed: {e}")
             raise
 
+    async def _fetch_library_docs(
+        self, library_name: str, library_topic: Optional[str], num_cards: int
+    ) -> Optional[str]:
+        """Fetch library documentation from Context7."""
+        logger.info(f"Fetching library documentation for: {library_name}")
+        try:
+            context7_client = Context7Client()
+
+            # Dynamic token allocation based on card generation needs
+            base_tokens = 8000
+            if num_cards > 40:
+                token_limit = 12000
+            elif num_cards > 20:
+                token_limit = 10000
+            else:
+                token_limit = base_tokens
+
+            if library_topic:
+                token_limit = int(token_limit * 0.8)
+
+            logger.info(
+                f"Fetching {token_limit} tokens of documentation"
+                + (f" for topic: {library_topic}" if library_topic else "")
+            )
+
+            library_docs = await context7_client.fetch_library_documentation(
+                library_name, topic=library_topic, tokens=token_limit
+            )
+
+            if library_docs:
+                logger.info(
+                    f"Added {len(library_docs)} chars of {library_name} documentation to context"
+                )
+                return library_docs
+            else:
+                logger.warning(
+                    f"Could not fetch documentation for library: {library_name}"
+                )
+                return None
+        except Exception as e:
+            logger.error(f"Error fetching library documentation: {e}")
+            return None
+
+    async def _generate_cards_per_topic(
+        self,
+        main_subject: str,
+        subject: str,
+        topics_list: List[str],
+        cards_per_topic: int,
+        difficulty: str,
+        context: Dict[str, Any],
+        generate_cloze: bool,
+    ) -> List[Card]:
+        """Generate cards for each topic in the topics_list."""
+        all_cards: List[Card] = []
+        total_topics = len(topics_list)
+
+        for i, subtopic in enumerate(topics_list):
+            topic_num = i + 1
+            logger.info(
+                f"Generating topic {topic_num}/{total_topics}: {subtopic} "
+                f"({cards_per_topic} cards)"
+            )
+
+            # Add topic context
+            topic_context = {
+                **context,
+                "main_subject": main_subject,
+                "topic_index": topic_num,
+                "total_topics": total_topics,
+                "current_subtopic": subtopic,
+            }
+
+            cards = await self._generation_phase(
+                topic=subtopic,
+                subject=subject,
+                num_cards=cards_per_topic,
+                difficulty=difficulty,
+                context=topic_context,
+                generate_cloze=generate_cloze,
+            )
+
+            all_cards.extend(cards)
+            logger.info(
+                f"Topic {topic_num}/{total_topics} complete: {len(cards)} cards. "
+                f"Total: {len(all_cards)}"
+            )
+
+        return all_cards
+
     async def _generation_phase(
         self,
         topic: str,

ankigen_core/agents/schemas.py

@@ -155,6 +155,12 @@ class AutoConfigSchema(BaseModel):
     topic_number: int = Field(
         ..., ge=2, le=20, description="Number of topics to generate (2-20)"
     )
+    topics_list: List[str] = Field(
+        ...,
+        min_length=2,
+        max_length=20,
+        description="List of distinct subtopics to cover, ordered by learning progression",
+    )
     cards_per_topic: int = Field(
         ..., ge=2, le=30, description="Number of cards per topic (2-30)"
     )

ankigen_core/auto_config.py

@@ -16,11 +16,30 @@ class AutoConfigService:
         self.context7_client = Context7Client()
 
     async def analyze_subject(
-        self, subject: str, openai_client: AsyncOpenAI
+        self,
+        subject: str,
+        openai_client: AsyncOpenAI,
+        target_topic_count: int | None = None,
     ) -> AutoConfigSchema:
-        """Analyze a subject string and return configuration settings"""
+        """Analyze a subject string and return configuration settings.
 
-        system_prompt = """You are an educational content analyzer specializing in spaced repetition learning. Analyze the given subject and determine flashcard generation settings that focus on ESSENTIAL concepts.
+        Args:
+            subject: The subject to analyze
+            openai_client: OpenAI client for LLM calls
+            target_topic_count: If provided, forces exactly this many topics in decomposition
+        """
+
+        # Build topic count instruction if override provided
+        topic_count_instruction = ""
+        if target_topic_count is not None:
+            topic_count_instruction = f"""
+IMPORTANT OVERRIDE: The user has requested exactly {target_topic_count} topics.
+You MUST set topic_number to {target_topic_count} and provide exactly {target_topic_count} items in topics_list.
+Choose the {target_topic_count} most important/foundational subtopics for this subject.
+"""
+
+        system_prompt = f"""You are an educational content analyzer specializing in spaced repetition learning. Analyze the given subject and determine flashcard generation settings that focus on ESSENTIAL concepts.
+{topic_count_instruction}
 
 CRITICAL PRINCIPLE: Quality over quantity. Focus on fundamental concepts that unlock understanding, not trivial facts.
 
@@ -32,14 +51,24 @@ Consider:
    - "Docker networking" → documentation_focus: "networking, network drivers, container communication"
 3. Identify the scope: narrow (specific feature), medium (several related topics), broad (full overview)
 4. Determine content type: concepts (theory/understanding), syntax (code/commands), api (library usage), practical (hands-on skills)
-5. Suggest number of topics and cards - aim for thorough learning (30-60 total cards minimum)
+5. TOPIC DECOMPOSITION: Break down the subject into distinct subtopics that together provide comprehensive coverage
 6. Recommend cloze cards for syntax/code, basic cards for concepts
 7. Choose model based on complexity: gpt-4.1 for complex topics, gpt-4.1-nano for basic/simple
 
+TOPIC DECOMPOSITION (topics_list):
+You MUST provide a topics_list - a list of distinct subtopics that together cover the subject comprehensively.
+- Each topic should be specific and non-overlapping
+- Order topics from foundational to advanced (learning progression)
+- The number of topics should match topic_number
+
+Examples:
+- "React Hooks" → topics_list: ["useState fundamentals", "useEffect and lifecycle", "useRef and useContext", "custom hooks patterns", "performance with useMemo/useCallback", "testing hooks"]
+- "Docker basics" → topics_list: ["containers vs VMs", "images and Dockerfile", "container lifecycle", "volumes and persistence", "networking fundamentals", "docker-compose basics"]
+- "Machine Learning" → topics_list: ["supervised vs unsupervised", "regression models", "classification models", "model evaluation metrics", "overfitting and regularization", "feature engineering", "cross-validation"]
+
 IMPORTANT - Focus on HIGH-VALUE topics:
 - GOOD topics: Core concepts, fundamental principles, mental models, design patterns, key abstractions
 - AVOID topics: Trivial commands (like "docker ps"), basic syntax that's easily googled, minor API details
-- Example: For Docker, focus on "container lifecycle", "image layers", "networking models" NOT "list of docker commands"
 
 Guidelines for settings (MINIMUM 30 cards total):
 - Narrow/specific scope: 4-5 essential topics with 8-10 cards each (32-50 cards)
@@ -53,12 +82,6 @@ Learning preference suggestions:
 - For practical: "Emphasize core patterns and principles with real-world applications"
 - For theory: "Build deep conceptual understanding with progressive complexity"
 
-Documentation focus examples (be specific and thorough):
-- "Basic Pandas Dataframe" → "dataframe creation, indexing, selection, basic operations, data types"
-- "React hooks" → "useState, useEffect, custom hooks, hook rules, common patterns"
-- "Docker basics" → "containers, images, Dockerfile, volumes, basic networking"
-- "TypeScript types" → "generics, conditional types, mapped types, utility types, type inference"
-
 Return a JSON object matching the AutoConfigSchema."""
 
         user_prompt = f"""Analyze this subject for flashcard generation: "{subject}"
@@ -89,10 +112,19 @@ Provide a brief rationale for your choices."""
         except Exception as e:
             logger.error(f"Failed to analyze subject: {e}")
             # Return sensible defaults on error (still aim for good card count)
+            # Use the subject as a single topic as fallback
             return AutoConfigSchema(
                 library_search_term="",
                 documentation_focus=None,
                 topic_number=6,
+                topics_list=[
+                    f"{subject} - fundamentals",
+                    f"{subject} - core concepts",
+                    f"{subject} - practical applications",
+                    f"{subject} - common patterns",
+                    f"{subject} - best practices",
+                    f"{subject} - advanced topics",
+                ],
                 cards_per_topic=8,
                 learning_preferences="Focus on fundamental concepts and core principles with practical examples",
                 generate_cloze=False,
@@ -103,13 +135,21 @@ Provide a brief rationale for your choices."""
             )
 
     async def auto_configure(
-        self, subject: str, openai_client: AsyncOpenAI
+        self,
+        subject: str,
+        openai_client: AsyncOpenAI,
+        target_topic_count: int | None = None,
     ) -> Dict[str, Any]:
         """
         Complete auto-configuration pipeline:
         1. Analyze subject with AI
         2. Search Context7 for library if detected
         3. Return complete configuration for UI
+
+        Args:
+            subject: The subject to analyze
+            openai_client: OpenAI client for LLM calls
+            target_topic_count: If provided, forces exactly this many topics
         """
 
         if not subject or not subject.strip():
@@ -119,7 +159,9 @@ Provide a brief rationale for your choices."""
         logger.info(f"Starting auto-configuration for subject: '{subject}'")
 
         # Step 1: Analyze the subject
-        config = await self.analyze_subject(subject, openai_client)
+        config = await self.analyze_subject(
+            subject, openai_client, target_topic_count=target_topic_count
+        )
 
         # Step 2: Search Context7 for library if one was detected
         library_id = None
@@ -145,6 +187,7 @@ Provide a brief rationale for your choices."""
             "library_name": config.library_search_term if library_id else "",
             "library_topic": config.documentation_focus or "",
             "topic_number": config.topic_number,
+            "topics_list": config.topics_list,
             "cards_per_topic": config.cards_per_topic,
             "preference_prompt": config.learning_preferences,
             "generate_cloze_checkbox": config.generate_cloze,

ankigen_core/card_generator.py

@@ -52,11 +52,6 @@ GENERATION_MODES = [
         "label": "Single Subject",
         "description": "Generate cards for a specific topic",
     },
-    {
-        "value": "path",
-        "label": "Learning Path",
-        "description": "Break down a job description or learning goal into subjects",
-    },
     {
         "value": "text",
         "label": "From Text",
@@ -140,6 +135,7 @@ async def orchestrate_card_generation(
     use_llm_judge: bool = False,
     library_name: str = None,
     library_topic: str = None,
+    topics_list: List[str] = None,
 ):
     """Orchestrates the card generation process based on UI inputs."""
     logger.info(f"Starting card generation orchestration in {generation_mode} mode")
@@ -175,6 +171,8 @@ async def orchestrate_card_generation(
             library_name=library_name,
             library_topic=library_topic,
             generate_cloze=generate_cloze,
+            topics_list=topics_list,
+            cards_per_topic=cards_per_topic,
         )
 
         token_usage_html = _get_token_usage_html(token_tracker)

ankigen_core/cli.py

@@ -13,6 +13,7 @@ from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
 from rich.table import Table
 from rich.panel import Panel
 
+from ankigen_core.agents.token_tracker import get_token_tracker
 from ankigen_core.auto_config import AutoConfigService
 from ankigen_core.card_generator import orchestrate_card_generation
 from ankigen_core.exporters import export_dataframe_to_apkg, export_dataframe_to_csv
@@ -55,13 +56,13 @@ async def auto_configure_from_prompt(
         await client_manager.initialize_client(api_key)
         openai_client = client_manager.get_client()
 
-        # Get auto-config
+        # Get auto-config (pass topic count override so LLM decomposes correctly)
         auto_config_service = AutoConfigService()
-        config = await auto_config_service.auto_configure(prompt, openai_client)
+        config = await auto_config_service.auto_configure(
+            prompt, openai_client, target_topic_count=override_topics
+        )
 
-    # Apply overrides
-    if override_topics is not None:
-        config["topic_number"] = override_topics
+    # Apply remaining overrides (topics already handled in auto_configure)
     if override_cards is not None:
         config["cards_per_topic"] = override_cards
     if override_model is not None:
@@ -86,6 +87,17 @@ async def auto_configure_from_prompt(
         table.add_row("Library", config.get("library_name"))
     if config.get("library_topic"):
         table.add_row("Library Topic", config.get("library_topic"))
+
+    # Display discovered topics
+    if config.get("topics_list"):
+        topics = config["topics_list"]
+        # Show first few topics, indicate if there are more
+        if len(topics) <= 4:
+            topics_str = ", ".join(topics)
+        else:
+            topics_str = ", ".join(topics[:3]) + f", ... (+{len(topics) - 3} more)"
+        table.add_row("Subtopics", topics_str)
+
     if config.get("preference_prompt"):
         table.add_row(
             "Learning Focus", config.get("preference_prompt", "")[:50] + "..."
@@ -142,6 +154,7 @@ async def generate_cards_from_config(
             library_topic=config.get("library_topic")
             if config.get("library_topic")
             else None,
+            topics_list=config.get("topics_list"),
         )
 
         progress.update(task, completed=100)
@@ -327,13 +340,17 @@ def main(
             summary.add_row("Output File:", f"[bold]{exported_path}[/bold]")
             summary.add_row("File Size:", f"{file_size:.1f} KB")
 
-            # Extract token count from HTML if available
-            if "tokens" in token_html.lower():
-                import re
-
-                token_match = re.search(r"(\d+)\s*tokens", token_html)
-                if token_match:
-                    summary.add_row("Tokens Used:", token_match.group(1))
+            # Get token usage from tracker
+            tracker = get_token_tracker()
+            session = tracker.get_session_summary()
+            if session["total_tokens"] > 0:
+                # Calculate totals across all models
+                total_input = sum(u.prompt_tokens for u in tracker.usage_history)
+                total_output = sum(u.completion_tokens for u in tracker.usage_history)
+                summary.add_row(
+                    "Tokens:",
+                    f"{total_input:,} in / {total_output:,} out ({session['total_tokens']:,} total)",
+                )
 
             console.print(
                 Panel(summary, border_style="green", title="Generation Complete")

ankigen_core/ui_logic.py

@@ -1,7 +1,7 @@
 # Module for functions that build or manage UI sections/logic
 
 import gradio as gr
-import pandas as pd  # Needed for use_selected_subjects type hinting
+import pandas as pd
 from typing import (
     Callable,
     List,
@@ -51,24 +51,19 @@ crawler_ui_logger = get_logger()  # Keep this definition
 def update_mode_visibility(
     mode: str,
     current_subject: str,
-    current_description: str,
     current_text: str,
     current_url: str,
 ):
     """Updates visibility and values of UI elements based on generation mode."""
     is_subject = mode == "subject"
-    is_path = mode == "path"
     is_text = mode == "text"
     is_web = mode == "web"
 
     # Determine value persistence or clearing
     subject_val = current_subject if is_subject else ""
-    description_val = current_description if is_path else ""
     text_val = current_text if is_text else ""
     url_val = current_url if is_web else ""
 
-    cards_output_visible = is_subject or is_text or is_web
-
     # Define standard columns for empty DataFrames
     main_output_df_columns = [
         "Index",
@@ -82,173 +77,22 @@ def update_mode_visibility(
         "Learning_Outcomes",
         "Difficulty",
     ]
-    subjects_list_df_columns = ["Subject", "Prerequisites", "Time Estimate"]
 
     return (
         gr.update(visible=is_subject),  # 1 subject_mode (Group)
-        gr.update(visible=is_path),  # 2 path_mode (Group)
-        gr.update(visible=is_text),  # 3 text_mode (Group)
-        gr.update(visible=is_web),  # 4 web_mode (Group for crawler UI)
-        gr.update(visible=is_path),  # 5 path_results (Group)
-        gr.update(
-            visible=cards_output_visible
-        ),  # 6 cards_output (Group for main table)
-        gr.update(value=subject_val),  # Now 7th item (was 8th)
-        gr.update(value=description_val),  # Now 8th item (was 9th)
-        gr.update(value=text_val),  # Now 9th item (was 10th)
-        gr.update(value=url_val),  # Now 10th item (was 11th)
+        gr.update(visible=is_text),  # 2 text_mode (Group)
+        gr.update(visible=is_web),  # 3 web_mode (Group for crawler UI)
+        gr.update(visible=True),  # 4 cards_output (always visible now)
+        gr.update(value=subject_val),  # 5 subject
+        gr.update(value=text_val),  # 6 source_text
+        gr.update(value=url_val),  # 7 web_crawl_url_input
         gr.update(
             value=pd.DataFrame(columns=main_output_df_columns)
-        ),  # Now 11th item (was 12th)
-        gr.update(
-            value=pd.DataFrame(columns=subjects_list_df_columns)
-        ),  # Now 12th item (was 13th)
-        gr.update(value=""),  # Now 13th item (was 14th)
-        gr.update(value=""),  # Now 14th item (was 15th)
+        ),  # 8 output (DataFrame)
         gr.update(
             value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
             visible=False,
-        ),  # Now 15th item (was 16th)
-    )
-
-
-def use_selected_subjects(subjects_df: pd.DataFrame | None):
-    """Updates UI to use subjects from learning path analysis."""
-    if subjects_df is None or subjects_df.empty:
-        gr.Warning("No subjects available to copy from Learning Path analysis.")
-        # Return updates that change nothing for all 18 outputs
-        return (
-            gr.update(),  # 1 generation_mode
-            gr.update(),  # 2 subject_mode
-            gr.update(),  # 3 path_mode
-            gr.update(),  # 4 text_mode
-            gr.update(),  # 5 web_mode
-            gr.update(),  # 6 path_results
-            gr.update(),  # 7 cards_output
-            gr.update(),  # 8 subject
-            gr.update(),  # 9 description
-            gr.update(),  # 10 source_text
-            gr.update(),  # 11 web_crawl_url_input
-            gr.update(),  # 12 topic_number
-            gr.update(),  # 13 preference_prompt
-            gr.update(
-                value=pd.DataFrame(
-                    columns=[
-                        "Index",
-                        "Topic",
-                        "Card_Type",
-                        "Question",
-                        "Answer",
-                        "Explanation",
-                        "Example",
-                        "Prerequisites",
-                        "Learning_Outcomes",
-                        "Difficulty",
-                    ]
-                )
-            ),  # 14 output (DataFrame)
-            gr.update(
-                value=pd.DataFrame(
-                    columns=["Subject", "Prerequisites", "Time Estimate"]
-                )
-            ),  # 15 subjects_list (DataFrame)
-            gr.update(),  # 16 learning_order
-            gr.update(),  # 17 projects
-            gr.update(visible=False),  # 18 total_cards_html
-        )
-
-    try:
-        subjects = subjects_df["Subject"].tolist()
-        combined_subject = ", ".join(subjects)
-        # Ensure suggested_topics is an int, Gradio sliders expect int/float for value
-        suggested_topics = int(min(len(subjects) + 1, 20))
-    except KeyError:
-        gr.Error("Learning path analysis result is missing the 'Subject' column.")
-        # Return no-change updates for all 18 outputs
-        return (
-            gr.update(),  # 1 generation_mode
-            gr.update(),  # 2 subject_mode
-            gr.update(),  # 3 path_mode
-            gr.update(),  # 4 text_mode
-            gr.update(),  # 5 web_mode
-            gr.update(),  # 6 path_results
-            gr.update(),  # 7 cards_output
-            gr.update(),  # 8 subject
-            gr.update(),  # 9 description
-            gr.update(),  # 10 source_text
-            gr.update(),  # 11 web_crawl_url_input
-            gr.update(),  # 12 topic_number
-            gr.update(),  # 13 preference_prompt
-            gr.update(
-                value=pd.DataFrame(
-                    columns=[
-                        "Index",
-                        "Topic",
-                        "Card_Type",
-                        "Question",
-                        "Answer",
-                        "Explanation",
-                        "Example",
-                        "Prerequisites",
-                        "Learning_Outcomes",
-                        "Difficulty",
-                    ]
-                )
-            ),  # 14 output (DataFrame)
-            gr.update(
-                value=pd.DataFrame(
-                    columns=["Subject", "Prerequisites", "Time Estimate"]
-                )
-            ),  # 15 subjects_list (DataFrame)
-            gr.update(),  # 16 learning_order
-            gr.update(),  # 17 projects
-            gr.update(visible=False),  # 18 total_cards_html
-        )
-
-    # Corresponds to outputs in app.py for use_subjects.click:
-    # [generation_mode, subject_mode, path_mode, text_mode, web_mode, path_results, cards_output,
-    #  subject, description, source_text, web_crawl_url_input, topic_number, preference_prompt,
-    #  output, subjects_list, learning_order, projects, total_cards_html]
-    return (
-        gr.update(value="subject"),  # 1 generation_mode (Radio)
-        gr.update(visible=True),  # 2 subject_mode (Group)
-        gr.update(visible=False),  # 3 path_mode (Group)
-        gr.update(visible=False),  # 4 text_mode (Group)
-        gr.update(visible=False),  # 5 web_mode (Group)
-        gr.update(visible=False),  # 6 path_results (Group)
-        gr.update(visible=True),  # 7 cards_output (Group)
-        gr.update(value=combined_subject),  # 8 subject (Textbox)
-        gr.update(value=""),  # 9 description (Textbox)
-        gr.update(value=""),  # 10 source_text (Textbox)
-        gr.update(value=""),  # 11 web_crawl_url_input (Textbox)
-        gr.update(value=suggested_topics),  # 12 topic_number (Slider)
-        gr.update(
-            value="Focus on connections between these subjects and their practical applications."
-        ),  # 13 preference_prompt (Textbox)
-        gr.update(
-            value=pd.DataFrame(
-                columns=[
-                    "Index",
-                    "Topic",
-                    "Card_Type",
-                    "Question",
-                    "Answer",
-                    "Explanation",
-                    "Example",
-                    "Prerequisites",
-                    "Learning_Outcomes",
-                    "Difficulty",
-                ]
-            )
-        ),  # 14 output (DataFrame) - Clear it
-        gr.update(
-            value=subjects_df
-        ),  # 15 subjects_list (DataFrame) - Keep the value that triggered this
-        gr.update(
-            value=""
-        ),  # 16 learning_order (Markdown) - Clear it or decide to keep
-        gr.update(value=""),  # 17 projects (Markdown) - Clear it or decide to keep
-        gr.update(visible=False),  # 18 total_cards_html (HTML)
+        ),  # 9 total_cards_html
     )
 
 

app.py

@@ -15,7 +15,6 @@ from ankigen_core.exporters import (
     export_dataframe_to_apkg,
     export_dataframe_to_csv,
 )  # Anki models (BASIC_MODEL, CLOZE_MODEL) are internal to exporters
-from ankigen_core.learning_path import analyze_learning_path
 from ankigen_core.llm_interface import (
     OpenAIClientManager,
 )  # structured_output_completion is internal to core modules
@@ -23,7 +22,6 @@ from ankigen_core.ui_logic import (
     crawl_and_generate,
     create_crawler_main_mode_elements,
     update_mode_visibility,
-    use_selected_subjects,
 )
 from ankigen_core.utils import (
     ResponseCache,
@@ -68,6 +66,16 @@ except (AttributeError, ImportError):
     # Fallback for older gradio versions or when themes are not available
     custom_theme = None
 
+# CSS for the interface (moved to module level for Gradio 6 compatibility)
+custom_css = """
+    #footer {display:none !important}
+    .tall-dataframe {min-height: 500px !important}
+    .contain {max-width: 100% !important; margin: auto;}
+    .output-cards {border-radius: 8px; box-shadow: 0 4px 6px -1px rgba(0,0,0,0.1);}
+    .hint-text {font-size: 0.9em; color: #666; margin-top: 4px;}
+    .export-group > .gradio-group { margin-bottom: 0 !important; padding-bottom: 5px !important; }
+"""
+
 # --- Example Data for Initialization ---
 example_data = pd.DataFrame(
     [
@@ -139,48 +147,8 @@ def get_recent_logs(logger_name="ankigen") -> str:
 
 def create_ankigen_interface():
     logger.info("Creating AnkiGen Gradio interface...")
-    with gr.Blocks(
-        theme=custom_theme,
-        title="AnkiGen",
-        css="""
-            #footer {display:none !important}
-            .tall-dataframe {min-height: 500px !important}
-            .contain {max-width: 100% !important; margin: auto;}
-            .output-cards {border-radius: 8px; box-shadow: 0 4px 6px -1px rgba(0,0,0,0.1);}
-            .hint-text {font-size: 0.9em; color: #666; margin-top: 4px;}
-            .export-group > .gradio-group { margin-bottom: 0 !important; padding-bottom: 5px !important; }
-
-            /* REMOVING CSS previously intended for DataFrame readability to ensure plain text */
-            /*
-            .explanation-text {
-                background: #f0fdf4;
-                border-left: 3px solid #4ade80;
-                padding: 0.5em;
-                margin-bottom: 0.5em;
-                border-radius: 4px;
-            }
-            .example-text-plain {
-                background: #fff7ed;
-                border-left: 3px solid #f97316;
-                padding: 0.5em;
-                margin-bottom: 0.5em;
-                border-radius: 4px;
-            }
-            pre code {
-                display: block;
-                padding: 0.8em;
-                background: #1e293b;
-                color: #e2e8f0;
-                border-radius: 4px;
-                overflow-x: auto;
-                font-family: 'Fira Code', 'Consolas', monospace;
-                font-size: 0.9em;
-                margin-bottom: 0.5em;
-            }
-            */
-        """,
-        js=js_storage,
-    ) as ankigen:
+    # Note: theme, css, and js moved to .launch() for Gradio 6 compatibility
+    with gr.Blocks(title="AnkiGen") as ankigen:
         with gr.Column(elem_classes="contain"):
             gr.Markdown("# 📚 AnkiGen - Anki Card Generator")
             gr.Markdown("#### Generate Anki flashcards using AI.")
@@ -208,16 +176,6 @@ def create_ankigen_interface():
                                 "Auto-fill",
                                 variant="secondary",
                             )
-                        with gr.Group(visible=False) as path_mode:
-                            description = gr.Textbox(
-                                label="Learning Goal",
-                                placeholder="Paste a job description...",
-                                lines=5,
-                            )
-                            analyze_button = gr.Button(
-                                "Analyze & Break Down",
-                                variant="secondary",
-                            )
                         with gr.Group(visible=False) as text_mode:
                             source_text = gr.Textbox(
                                 label="Source Text",
@@ -329,21 +287,6 @@ def create_ankigen_interface():
 
             generate_button = gr.Button("Generate Cards", variant="primary")
 
-            with gr.Group(visible=False) as path_results:
-                gr.Markdown("### Learning Path Analysis")
-                subjects_list = gr.Dataframe(
-                    headers=["Subject", "Prerequisites", "Time Estimate"],
-                    label="Recommended Subjects",
-                    interactive=False,
-                )
-                learning_order = gr.Markdown("### Recommended Learning Order")
-                projects = gr.Markdown("### Suggested Projects")
-                use_subjects = gr.Button("Use These Subjects ℹ️", variant="primary")
-                gr.Markdown(
-                    "*Click to copy subjects to main input*",
-                    elem_classes="hint-text",
-                )
-
             with gr.Group() as cards_output:
                 gr.Markdown("### Generated Cards")
                 with gr.Accordion("Output Format", open=False):
@@ -421,93 +364,18 @@ def create_ankigen_interface():
                 inputs=[
                     generation_mode,
                     subject,
-                    description,
                     source_text,
                     web_crawl_url_input,
                 ],
                 outputs=[
                     subject_mode,
-                    path_mode,
-                    text_mode,
-                    web_mode,
-                    path_results,
-                    cards_output,
-                    subject,
-                    description,
-                    source_text,
-                    web_crawl_url_input,
-                    output,
-                    subjects_list,
-                    learning_order,
-                    projects,
-                    total_cards_html,
-                ],
-            )
-
-            # Define an async wrapper for the analyze_learning_path partial
-            async def handle_analyze_click(
-                api_key_val,
-                description_val,
-                model_choice_val,
-                progress=gr.Progress(track_tqdm=True),  # Added progress tracker
-            ):
-                try:
-                    # Call analyze_learning_path directly, as client_manager and response_cache are in scope
-                    return await analyze_learning_path(
-                        client_manager,  # from global scope
-                        response_cache,  # from global scope
-                        api_key_val,
-                        description_val,
-                        model_choice_val,
-                    )
-                except gr.Error as e:  # Catch the specific Gradio error
-                    logger.error(f"Learning path analysis failed: {e}", exc_info=True)
-                    # Re-raise the error so Gradio displays it to the user
-                    # And return appropriate empty updates for the outputs
-                    # to prevent a subsequent Gradio error about mismatched return values.
-                    gr.Error(str(e))  # This will be shown in the UI.
-                    empty_subjects_df = pd.DataFrame(
-                        columns=["Subject", "Prerequisites", "Time Estimate"],
-                    )
-                    return (
-                        gr.update(
-                            value=empty_subjects_df,
-                        ),  # For subjects_list (DataFrame)
-                        gr.update(value=""),  # For learning_order (Markdown)
-                        gr.update(value=""),  # For projects (Markdown)
-                    )
-
-            analyze_button.click(
-                fn=handle_analyze_click,  # MODIFIED: Use the new async handler
-                inputs=[
-                    api_key_input,
-                    description,
-                    model_choice,
-                ],
-                outputs=[subjects_list, learning_order, projects],
-            )
-
-            use_subjects.click(
-                fn=use_selected_subjects,
-                inputs=[subjects_list],
-                outputs=[
-                    generation_mode,
-                    subject_mode,
-                    path_mode,
                     text_mode,
                     web_mode,
-                    path_results,
                     cards_output,
                     subject,
-                    description,
                     source_text,
                     web_crawl_url_input,
-                    topic_number,
-                    preference_prompt,
                     output,
-                    subjects_list,
-                    learning_order,
-                    projects,
                     total_cards_html,
                 ],
             )
@@ -920,13 +788,21 @@ if __name__ == "__main__":
         logger.info("Launching AnkiGen Gradio interface...")
 
         # Configure for HuggingFace Spaces vs local development
+        # Note: theme, css, js moved to launch() for Gradio 6 compatibility
+        launch_kwargs = {
+            "theme": custom_theme,
+            "css": custom_css,
+            "js": js_storage,
+        }
         if os.environ.get("SPACE_ID"):  # On HuggingFace Spaces
             # Let HuggingFace handle all the configuration
-            ankigen_interface.queue(default_concurrency_limit=2, max_size=10).launch()
+            ankigen_interface.queue(default_concurrency_limit=2, max_size=10).launch(
+                **launch_kwargs
+            )
         else:  # Local development
             # Use auto port finding for local dev
             ankigen_interface.queue(default_concurrency_limit=2, max_size=10).launch(
-                server_name="127.0.0.1", share=False
+                server_name="127.0.0.1", share=False, **launch_kwargs
             )
     except Exception as e:
         logger.critical(f"Failed to launch Gradio interface: {e}", exc_info=True)