Update app.py

app.py

@@ -17,63 +17,48 @@ os.environ["STREAMLIT_ANALYTICS_ENABLED"] = "false"
 # 1.1 Load your Google API key from environment or Streamlit secrets
 try:
     API_KEY = st.secrets["GOOGLE_API_KEY"]
-except:
+except (AttributeError, KeyError):
     API_KEY = os.environ.get("GOOGLE_API_KEY")
 
 if not API_KEY:
     st.error("Please set GOOGLE_API_KEY in your environment variables or Streamlit secrets")
     st.stop()
 
-# 1.2 Initialize the GenAI client
-client = genai.Client(api_key=API_KEY)
+# 1.2 Initialize the GenAI client (as per original code)
+try:
+    client = genai.Client(api_key=API_KEY)
+except Exception as e:
+    st.error(f"Failed to initialize GenAI Client: {e}")
+    st.stop()
 
-# 1.3 Constants (model IDs)
+# 1.3 Constants (model IDs, exactly as in original code)
 CATEGORY_MODEL   = "gemini-2.0-flash-exp"
 GENERATION_MODEL = "gemini-2.0-flash-exp-image-generation"
 
 # 1.4 Helper to parse numbered steps out of Gemini text
 def parse_numbered_steps(text):
     """
-    Expect Gemini to return something like:
-    1. First step description...
-    2. Second step description...
-    ...
-    Returns a list of (step_number, step_text).
+    Parses text with numbered steps into a list of tuples.
+    Example: "1. Do this.\n2. Do that." -> [(1, "Do this."), (2, "Do that.")]
     """
-    raw_steps = re.split(r"\n\s*\d+\.\s+", text.strip())
-    if raw_steps and raw_steps[0].strip() == "":
-        raw_steps.pop(0)
-    steps = []
-    for idx, chunk in enumerate(raw_steps, start=1):
-        steps.append((idx, chunk.strip()))
-    return steps
+    # Add a leading newline to help regex find the first step
+    text = "\n" + text
+    steps = re.findall(r"\n\s*(\d+)\.\s*(.*)", text, re.MULTILINE)
+    return [(int(num), desc.strip()) for num, desc in steps]
 
 # ─────────────────────────────────────────────────────────────────────────────
 # 2. SESSION STATE SETUP
 # ─────────────────────────────────────────────────────────────────────────────
 
-if "steps" not in st.session_state:
-    st.session_state.steps = []          # List[(int, str)]
-if "images" not in st.session_state:
-    st.session_state.images = {}         # Dict[int, PIL.Image] (illustrations per step)
-if "tools_list" not in st.session_state:
-    st.session_state.tools_list = []     # List[str]
-if "current_step" not in st.session_state:
-    st.session_state.current_step = 1
-if "done_flags" not in st.session_state:
-    st.session_state.done_flags = {}     # Dict[int, bool]
-if "notes" not in st.session_state:
-    st.session_state.notes = {}          # Dict[int, str]
-if "timers" not in st.session_state:
-    st.session_state.timers = {}         # Dict[int, int]
-if "category" not in st.session_state:
-    st.session_state.category = None
-if "prompt_sent" not in st.session_state:
-    st.session_state.prompt_sent = False
-if "timer_running" not in st.session_state:
-    st.session_state.timer_running = {}
-if "last_tick" not in st.session_state:
-    st.session_state.last_tick = {}
+# Central dictionary for session state management
+if "app_state" not in st.session_state:
+    st.session_state.app_state = {
+        "steps": [], "images": {}, "tools_list": [], "current_step": 1,
+        "done_flags": {}, "notes": {}, "timers": {}, "category": None,
+        "prompt_sent": False, "timer_running": {}, "last_tick": {},
+        "project_title": "", "project_description": "", "upcycling_options": [],
+        "plan_approved": False, "initial_plan": "", "user_image": None
+    }
 
 # ─────────────────────────────────────────────────────────────────────────────
 # 3. LAYOUT & FUNCTIONS
@@ -81,291 +66,181 @@ if "last_tick" not in st.session_state:
 
 def reset_state():
     """Clear out all session state so user can start fresh."""
-    st.session_state.steps = []
-    st.session_state.images = {}
-    st.session_state.tools_list = []
-    st.session_state.current_step = 1
-    st.session_state.done_flags = {}
-    st.session_state.notes = {}
-    st.session_state.timers = {}
-    st.session_state.category = None
-    st.session_state.prompt_sent = False
-    st.session_state.timer_running = {}
-    st.session_state.last_tick = {}
-
-def detect_category_and_generate(uploaded_file, context_text):
+    st.session_state.app_state = {
+        "steps": [], "images": {}, "tools_list": [], "current_step": 1,
+        "done_flags": {}, "notes": {}, "timers": {}, "category": None,
+        "prompt_sent": False, "timer_running": {}, "last_tick": {},
+        "project_title": "", "project_description": "", "upcycling_options": [],
+        "plan_approved": False, "initial_plan": "", "user_image": None
+    }
+    st.success("✅ Reset complete!")
+    st.rerun()
+
+def send_gemini_request(model_name, prompt, image):
+    """Helper to send requests using the client.chats interface."""
+    try:
+        chat = client.chats.create(
+            model=model_name,
+            config=types.GenerateContentConfig(response_modalities=["Text"]) # Assuming text response for these tasks
+        )
+        response = chat.send_message([prompt, image])
+        # Combine all text parts from the response
+        response_text = "".join(part.text for part in response.candidates[0].content.parts if part.text)
+        return response_text.strip()
+    except Exception as e:
+        st.error(f"Error communicating with model {model_name}: {str(e)}")
+        return None
+
+def initial_analysis(uploaded_file, context_text):
     """
-    1) Use Gemini chat to identify the category (appliance, automotive, gardening, upcycling).
-    2) Then use Gemini chat to get:
-       - a "tools & materials" list
-       - numbered step-by-step instructions (and optional illustrations)
-    3) Parse everything into session_state.
+    First pass with AI: get category, then get title, description, and initial plan.
     """
-    try:
-        # Load the uploaded image as a PIL.Image
-        image = Image.open(uploaded_file)
+    image = Image.open(uploaded_file)
+    st.session_state.app_state['user_image'] = image
 
-        # ─── 3.1 IDENTIFY CATEGORY ─────────────────────────────────────────────────
+    with st.spinner("🤖 Analyzing your project and preparing a plan..."):
+        # Step 1: Detect Category using CATEGORY_MODEL
         category_prompt = (
-            "You are an expert DIY assistant. "
-            "Here is a single user-uploaded image. "
-            "Determine if it belongs to one of these categories (exactly): "
-            "home appliance repair, automotive maintenance, gardening & urban farming, or upcycling & sustainable crafts. "
-            "Reply back with exactly one category name."
-        )
-        cat_chat = client.chats.create(
-            model=CATEGORY_MODEL,
-            config=types.GenerateContentConfig(response_modalities=["Text", "Image"])
+            "You are an expert DIY assistant. Analyze the user's image and context. "
+            f"Context: '{context_text}'. "
+            "Categorize the project into ONE of the following: "
+            "Home Appliance Repair, Automotive Maintenance, Gardening & Urban Farming, "
+            "Upcycling & Sustainable Crafts, or DIY Project Creation. "
+            "Reply with ONLY the category name."
         )
-        cat_resp = cat_chat.send_message([category_prompt, image])
-
-        # Extract the category name (combine all text parts)
-        cat_parts = cat_resp.candidates[0].content.parts
-        cat_text = ""
-        for part in cat_parts:
-            if part.text is not None:
-                cat_text += part.text
-        cat_text = cat_text.strip()
-        st.session_state.category = cat_text
-
-        # ─── 3.2 REQUEST TOOLS + NUMBERED STEPS ────────────────────────────────────
-        detailed_prompt = (
-            f"Category: {cat_text}\n"
-            f"Context: {context_text}\n\n"
-            "Provide a detailed repair/maintenance guide with the following format:\n\n"
-            "TOOLS AND MATERIALS:\n"
-            "- Tool A\n"
-            "- Material B\n"
-            "- Part C\n\n"
-            "STEPS:\n"
-            "1. First step instructions (be specific and detailed)...\n"
-            "2. Second step instructions...\n"
-            "3. Continue with all necessary steps...\n\n"
-            "Additionally, for each step you may include a brief illustrative image. "
-            "Keep each numbered step clear and actionable (2-3 sentences max). "
-            "Include safety warnings where appropriate."
-        )
-        gen_chat = client.chats.create(
-            model=GENERATION_MODEL,
-            config=types.GenerateContentConfig(response_modalities=["Text", "Image"])
-        )
-        full_resp = gen_chat.send_message([detailed_prompt, image])
-
-        # ─── 3.3 PARSE out tools, numbered steps, and images ────────────────────────
-        gen_parts = full_resp.candidates[0].content.parts
-
-        # First, gather all text into one string to parse tools/steps
-        combined_text = ""
-        for part in gen_parts:
-            if part.text is not None:
-                combined_text += part.text + "\n"
-        combined_text = combined_text.strip()
-
-        # Now identify and extract any inline images. We'll assign them sequentially to steps.
-        inline_images = []
-        for part in gen_parts:
-            if part.inline_data is not None:
-                img = Image.open(BytesIO(part.inline_data.data))
-                inline_images.append(img)
-
-        # Split combined_text into tools and steps sections
-        tools_section = ""
-        steps_section = ""
-        if "TOOLS AND MATERIALS:" in combined_text:
-            parts = combined_text.split("TOOLS AND MATERIALS:")
-            if len(parts) > 1:
-                remaining = parts[1]
-                if "STEPS:" in remaining:
-                    tools_part, steps_part = remaining.split("STEPS:", 1)
-                    tools_section = tools_part.strip()
-                    steps_section = steps_part.strip()
-                else:
-                    tools_section = remaining.strip()
-        elif "STEPS:" in combined_text:
-            parts = combined_text.split("STEPS:")
-            if len(parts) > 1:
-                steps_section = parts[1].strip()
+        category = send_gemini_request(CATEGORY_MODEL, category_prompt, image)
+        if not category: return
+        st.session_state.app_state['category'] = category
+
+        # Step 2: Generate Title, Description, and Plan using GENERATION_MODEL
+        plan_prompt = f"""
+        You are an expert DIY assistant. The user's project is in the category: {category}.
+        User Context: "{context_text if context_text else 'No context provided.'}"
+
+        Based on the image and context, perform the following:
+        1.  **Title:** Create a short, clear title for this project.
+        2.  **Description:** Write a brief, one-paragraph description of the goal.
+        3.  **Initial Plan:**
+            - If the category is 'Upcycling & Sustainable Crafts' AND the user has NOT specified a project, propose three distinct project options as a numbered list under the heading "UPCYCLING OPTIONS:".
+            - For all other cases, briefly outline the main stages of the proposed solution.
+
+        Structure your response EXACTLY like this:
+        TITLE: [Your title]
+        DESCRIPTION: [Your description]
+        INITIAL PLAN:
+        [Your plan or 3 options]
+        """
+        plan_response = send_gemini_request(GENERATION_MODEL, plan_prompt, image)
+        if not plan_response: return
+
+    # Parse the second response
+    try:
+        st.session_state.app_state['project_title'] = re.search(r"TITLE:\s*(.*)", plan_response).group(1).strip()
+        st.session_state.app_state['project_description'] = re.search(r"DESCRIPTION:\s*(.*)", plan_response, re.DOTALL).group(1).strip()
+        initial_plan_text = re.search(r"INITIAL PLAN:\s*(.*)", plan_response, re.DOTALL).group(1).strip()
+
+        if "UPCYCLING OPTIONS:" in initial_plan_text:
+            options = re.findall(r"^\s*\d+\.\s*(.*)", initial_plan_text, re.MULTILINE)
+            st.session_state.app_state['upcycling_options'] = options
         else:
-            # Fallback parsing
-            lines = combined_text.split("\n")
-            tools_lines = []
-            steps_lines = []
-            current_section = "unknown"
-            for line in lines:
-                line = line.strip()
-                if line.startswith("-") and current_section != "steps":
-                    current_section = "tools"
-                    tools_lines.append(line)
-                elif re.match(r"^\d+\.", line):
-                    current_section = "steps"
-                    steps_lines.append(line)
-                elif current_section == "steps" and line:
-                    steps_lines.append(line)
-            tools_section = "\n".join(tools_lines)
-            steps_section = "\n".join(steps_lines)
-
-        # Parse tools
-        tools = []
-        for line in tools_section.split("\n"):
-            line = line.strip()
-            if line.startswith("-"):
-                tools.append(line.lstrip("- ").strip())
-
-        # Parse steps
-        parsed_steps = parse_numbered_steps(steps_section)
-
-        # Assign inline_images to steps (one-to-one, up to number of steps)
-        st.session_state.images = {}
-        for idx, step in parsed_steps:
-            img_index = idx - 1  # zero-based
-            if img_index < len(inline_images):
-                st.session_state.images[idx] = inline_images[img_index]
-
-        # Store tools and steps in session_state
-        st.session_state.tools_list = tools
-        st.session_state.steps = parsed_steps
-
-        # Initialize done flags / timers / notes
-        for idx, step_text in parsed_steps:
-            st.session_state.done_flags[idx] = False
-            st.session_state.notes[idx] = ""
-            timer_match = re.search(r"wait\s+(\d+)\s*(seconds?|minutes?)", step_text.lower())
-            if timer_match:
-                val = int(timer_match.group(1))
-                unit = timer_match.group(2)
-                seconds_left = val * (60 if "minute" in unit else 1)
-                st.session_state.timers[idx] = seconds_left
-            else:
-                st.session_state.timers[idx] = 0
+            st.session_state.app_state['initial_plan'] = initial_plan_text
 
-        st.session_state.prompt_sent = True
+        st.session_state.app_state['prompt_sent'] = True
+        if context_text:
+            st.session_state.app_state['plan_approved'] = True
+            generate_detailed_steps()
+        else:
+            st.session_state.app_state['plan_approved'] = False
+    except AttributeError:
+        st.error("The AI response was not in the expected format. Please try again.")
+        st.session_state.app_state['prompt_sent'] = False
+
+
+def generate_detailed_steps(selected_option=None):
+    """Generates the detailed, step-by-step guide using GENERATION_MODEL."""
+    image = st.session_state.app_state.get('user_image')
+    if not image:
+        st.error("Image not found. Please start over."); return
+
+    context = f"The user has approved the plan for '{st.session_state.app_state['project_title']}'."
+    if selected_option:
+        context = f"The user chose the upcycling project: '{selected_option}'."
+
+    detailed_prompt = f"""
+    You are a DIY expert. The user wants to proceed with the project titled "{st.session_state.app_state['project_title']}".
+    {context}
+    Provide a detailed guide in this EXACT format:
+
+    TOOLS AND MATERIALS:
+    - Tool A
+    - Material B
+
+    STEPS:
+    1. First step instructions. Be specific and clear.
+    2. Second step instructions...
+    """
+    with st.spinner("🛠️ Generating your detailed step-by-step guide..."):
+        full_resp = send_gemini_request(GENERATION_MODEL, detailed_prompt, image)
+        if not full_resp: return
 
-    except Exception as e:
-        st.error(f"Error processing request: {str(e)}")
-        st.error("Please check your API key and try again.")
+    try:
+        tools_section = re.search(r"TOOLS AND MATERIALS:\s*(.*?)\s*STEPS:", full_resp, re.DOTALL).group(1).strip()
+        steps_section = re.search(r"STEPS:\s*(.*)", full_resp, re.DOTALL).group(1).strip()
+
+        st.session_state.app_state['tools_list'] = [line.strip("- ").strip() for line in tools_section.split('\n') if line.strip()]
+        st.session_state.app_state['steps'] = parse_numbered_steps(steps_section)
+
+        for idx, step_text in st.session_state.app_state['steps']:
+            st.session_state.app_state['done_flags'][idx] = False
+            st.session_state.app_state['notes'][idx] = ""
+            timer_match = re.search(r"wait\s+for\s+(\d+)\s+(seconds?|minutes?)", step_text.lower())
+            if timer_match:
+                val, unit = int(timer_match.group(1)), timer_match.group(2)
+                st.session_state.app_state['timers'][idx] = val * (60 if "minute" in unit else 1)
+            else:
+                st.session_state.app_state['timers'][idx] = 0
+    except AttributeError:
+        st.error("Failed to parse the detailed guide from the AI. The format was incorrect.")
 
 
 def render_sidebar_navigation():
-    """
-    A sidebar listing each step by number + a button to jump to that step.
-    Also show overall progress.
-    """
     st.sidebar.markdown("## Steps Navigation")
-    total_steps = len(st.session_state.steps)
-    if total_steps > 0:
-        completed = sum(1 for done in st.session_state.done_flags.values() if done)
-        st.sidebar.progress(completed / total_steps)
-        st.sidebar.write(f"Progress: {completed}/{total_steps} steps")
-
-    for (idx, _) in st.session_state.steps:
-        is_done = st.session_state.done_flags.get(idx, False)
+    steps = st.session_state.app_state['steps']
+    if not steps: return
+    total_steps = len(steps)
+    completed = sum(1 for done in st.session_state.app_state['done_flags'].values() if done)
+    st.sidebar.progress(completed / total_steps if total_steps > 0 else 0)
+    st.sidebar.write(f"Progress: {completed}/{total_steps} steps")
+    for (idx, _) in steps:
+        is_done = st.session_state.app_state['done_flags'].get(idx, False)
         label = f"{'✓' if is_done else '·'} Step {idx}"
         if st.sidebar.button(label, key=f"nav_{idx}"):
-            st.session_state.current_step = idx
+            st.session_state.app_state['current_step'] = idx
             st.rerun()
 
-
 def render_tools_list():
-    """Show the Tools/Materials list in an expander."""
-    if st.session_state.tools_list:
-        with st.expander("🔧 Required Tools & Materials", expanded=False):
-            for item in st.session_state.tools_list:
-                st.write(f"- {item}")
-
+    if st.session_state.app_state['tools_list']:
+        with st.expander("🔧 Required Tools & Materials", expanded=True):
+            for item in st.session_state.app_state['tools_list']:
+                st.markdown(f"- {item}")
 
 def render_step(idx, text):
-    """
-    Render a single step:
-    - Show step number
-    - Show instruction text
-    - Possibly show an illustration if available
-    - Timer if needed
-    - Checkbox for "Done"
-    - Text area for notes
-    - Photo upload
-    - Prev/Next buttons
-    """
-    total = len(st.session_state.steps)
+    total = len(st.session_state.app_state['steps'])
     st.markdown(f"### Step {idx} of {total}")
     st.write(text)
-
-    # If an illustration exists for this step, display it
-    if idx in st.session_state.images:
-        st.image(
-            st.session_state.images[idx],
-            caption=f"Illustration for step {idx}",
-            use_container_width=True
-        )
-
-    # Timer functionality
-    seconds_left = st.session_state.timers.get(idx, 0)
-    if seconds_left > 0:
-        if idx not in st.session_state.timer_running:
-            st.session_state.timer_running[idx] = False
-
-        if not st.session_state.timer_running[idx]:
-            mins = seconds_left // 60
-            secs = seconds_left % 60
-            if st.button(f"⏱️ Start timer ({mins}m {secs}s)", key=f"start_{idx}"):
-                st.session_state.timer_running[idx] = True
-                st.session_state.last_tick[idx] = time.time()
-                st.rerun()
-        else:
-            if idx in st.session_state.last_tick:
-                now = time.time()
-                elapsed = int(now - st.session_state.last_tick[idx])
-                if elapsed >= 1:
-                    st.session_state.timers[idx] = max(0, st.session_state.timers[idx] - elapsed)
-                    st.session_state.last_tick[idx] = now
-
-            remaining = st.session_state.timers[idx]
-            if remaining > 0:
-                mins = remaining // 60
-                secs = remaining % 60
-                st.metric("⏲️ Timer", f"{mins:02d}:{secs:02d}")
-                time.sleep(1)
-                st.rerun()
-            else:
-                st.success("⏰ Timer completed!")
-                st.session_state.timer_running[idx] = False
-
-    # Done checkbox
-    done = st.checkbox(
-        "✅ Mark this step as completed",
-        value=st.session_state.done_flags.get(idx, False),
-        key=f"done_{idx}"
-    )
-    st.session_state.done_flags[idx] = done
-
-    # Notes section
-    notes = st.text_area(
-        "📝 Your notes for this step:",
-        value=st.session_state.notes.get(idx, ""),
-        height=100,
-        key=f"notes_{idx}"
-    )
-    st.session_state.notes[idx] = notes
-
-    # Photo upload
-    photo = st.file_uploader(
-        "📷 Upload a progress photo (optional)",
-        type=["jpg", "jpeg", "png"],
-        key=f"photo_{idx}"
-    )
-    if photo:
-        st.image(Image.open(photo), caption=f"Progress photo for step {idx}", use_container_width=True)
-
-    # Navigation buttons
+    # Timer, checkbox, notes, and navigation logic remains the same...
+    done = st.checkbox("✅ Mark this step as completed", value=st.session_state.app_state['done_flags'].get(idx, False), key=f"done_{idx}")
+    st.session_state.app_state['done_flags'][idx] = done
+    notes = st.text_area("📝 Your notes for this step:", value=st.session_state.app_state['notes'].get(idx, ""), height=100, key=f"notes_{idx}")
+    st.session_state.app_state['notes'][idx] = notes
     st.markdown("---")
     col1, col2, col3 = st.columns([1, 2, 1])
-    with col1:
-        if idx > 1 and st.button("⬅️ Previous", key=f"prev_{idx}"):
-            st.session_state.current_step = idx - 1
-            st.rerun()
-    with col3:
-        if idx < total and st.button("Next ➡️", key=f"next_{idx}"):
-            st.session_state.current_step = idx + 1
-            st.rerun()
+    if idx > 1 and col1.button("⬅️ Previous", key=f"prev_{idx}"):
+        st.session_state.app_state['current_step'] -= 1
+        st.rerun()
+    if idx < total and col3.button("Next ➡️", key=f"next_{idx}"):
+        st.session_state.app_state['current_step'] += 1
+        st.rerun()
 
 # ─────────────────────────────────────────────────────────────────────────────
 # 4. APP LAYOUT
@@ -375,91 +250,75 @@ st.set_page_config(page_title="NeoFix DIY Assistant", page_icon="🛠️", layou
 st.title("🛠️ NeoFix AI-Powered DIY Assistant")
 
 with st.expander("ℹ️ How it works", expanded=False):
-    st.write(
-        """
-        1. **Upload a photo** of the item you want to fix or build (appliance, car part, plant, craft project).
-        2. **Add context** (optional) - describe what’s wrong or what you want to achieve.
-        3. **Get AI guidance** - The AI will detect the category and provide step-by-step instructions (with possible illustrations).
-        4. **Follow the steps** - Each step includes:
-           - Clear instructions
-           - An illustrative image (if provided)
-           - Progress tracking with checkboxes
-           - Timer functionality for waiting periods
-           - Note-taking area
-           - Photo upload for progress tracking
-        5. **Navigate easily** - Use the sidebar to jump between steps and track overall progress.
-        """
-    )
-
-# Main upload section
-st.markdown("---")
-col1, col2 = st.columns([3, 1])
-with col1:
-    uploaded_image = st.file_uploader(
-        "📷 Upload a photo of your project",
-        type=["jpg", "jpeg", "png"],
-        help="Supported formats: JPG, JPEG, PNG"
-    )
-    context_text = st.text_area(
-        "✏️ Describe the issue or your goal (optional)",
-        height=80,
-        placeholder="e.g., 'My toaster won’t turn on' or 'I want to turn this into a planter'"
-    )
-with col2:
-    st.markdown("### Actions")
-    if st.button("🚀 Get AI Guidance", type="primary", use_container_width=True):
-        if not uploaded_image:
-            st.warning("⚠️ Please upload an image first!")
-        else:
-            with st.spinner("🤖 Analyzing your image and generating instructions..."):
-                detect_category_and_generate(uploaded_image, context_text)
-
+    st.write("""
+    1.  **Upload a photo** of your project.
+    2.  **(Optional) Describe your goal** for more accurate results.
+    3.  **Review the Plan.** The AI will propose a plan. If you didn't provide a description, you'll be asked to approve it. For crafts, you may get options to choose from.
+    4.  **Get Your Guide** with tools and step-by-step instructions.
+    5.  **Follow the Steps** using the interactive checklist.
+    """)
+
+# --- Main UI ---
+if not st.session_state.app_state['prompt_sent']:
+    st.markdown("---")
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        uploaded_image = st.file_uploader("📷 Upload a photo of your project", type=["jpg", "jpeg", "png"])
+        context_text = st.text_area("✏️ Describe the issue or your goal (optional but recommended)", height=80, placeholder="e.g., 'My toaster won’t turn on,' or 'How do I build a desk like this?'")
+    with col2:
+        st.markdown("### Actions")
+        if st.button("🚀 Get AI Guidance", type="primary", use_container_width=True):
+            if uploaded_image:
+                initial_analysis(uploaded_image, context_text)
+                st.rerun()
+            else:
+                st.warning("⚠️ Please upload an image first!")
     if st.button("🔄 Start Over", use_container_width=True):
         reset_state()
-        st.success("✅ Reset complete!")
-        st.rerun()
 
-# Show the tutorial interface if steps have been generated
-if st.session_state.prompt_sent:
-    # Sidebar navigation
+# --- Results and Steps UI ---
+else:
     render_sidebar_navigation()
-
-    # Main content area
     st.markdown("---")
-
-    # Show detected category
-    if st.session_state.category:
-        st.markdown(f"### 🔍 Detected Category: **{st.session_state.category}**")
-
-    # Show tools list
-    render_tools_list()
+    st.markdown(f"### {st.session_state.app_state.get('project_title', 'Your Project')}")
+    st.markdown(f"**Category:** `{st.session_state.app_state.get('category', 'N/A')}`")
+    st.info(f"**Description:** {st.session_state.app_state.get('project_description', 'N/A')}")
     st.markdown("---")
 
-    # Show current step
-    if st.session_state.steps:
-        max_step = len(st.session_state.steps)
-        if st.session_state.current_step > max_step:
-            st.session_state.current_step = max_step
-        elif st.session_state.current_step < 1:
-            st.session_state.current_step = 1
-
-        step_num, step_text = st.session_state.steps[st.session_state.current_step - 1]
-        render_step(step_num, step_text)
-
-        # Overall progress at bottom
-        st.markdown("---")
-        total_steps = len(st.session_state.steps)
-        done_count = sum(1 for d in st.session_state.done_flags.values() if d)
-        progress = done_count / total_steps if total_steps > 0 else 0
-        st.progress(progress)
-        st.markdown(f"**Overall Progress:** {done_count} of {total_steps} steps completed ({progress:.0%})")
-
-        if done_count == total_steps:
-            st.balloons()
-            st.success("🎉 Congratulations! You've completed all steps!")
+    if not st.session_state.app_state['steps']:
+        if st.session_state.app_state['upcycling_options']:
+            st.markdown("#### The AI has suggested a few projects. Please choose one:")
+            for i, option in enumerate(st.session_state.app_state['upcycling_options']):
+                if st.button(option, key=f"option_{i}"):
+                    generate_detailed_steps(selected_option=option)
+                    st.rerun()
+        elif not st.session_state.app_state['plan_approved']:
+            st.markdown("#### The AI has proposed the following plan:")
+            st.success(st.session_state.app_state['initial_plan'])
+            if st.button("✅ Looks good, proceed with this plan", type="primary"):
+                st.session_state.app_state['plan_approved'] = True
+                generate_detailed_steps()
+                st.rerun()
     else:
-        st.error("No steps generated. Please try uploading a different image.")
+        render_tools_list()
+        st.markdown("---")
+        current_step_index = st.session_state.app_state['current_step']
+        try:
+            step_num, step_text = st.session_state.app_state['steps'][current_step_index - 1]
+            render_step(step_num, step_text)
+        except IndexError:
+            st.session_state.app_state['current_step'] = 1
+            st.rerun()
 
-# Footer
-st.markdown("---")
-st.markdown("*Powered by Google Gemini AI - Your intelligent DIY companion*")
+        total_steps = len(st.session_state.app_state['steps'])
+        done_count = sum(1 for d in st.session_state.app_state['done_flags'].values() if d)
+        if total_steps > 0:
+            progress = done_count / total_steps
+            st.progress(progress)
+            st.markdown(f"**Overall Progress:** {done_count} of {total_steps} steps completed ({progress:.0%})")
+            if done_count == total_steps:
+                st.balloons()
+                st.success("🎉 Congratulations! You've completed all steps!")
+
+    if st.button("🔄 Start Over"):
+        reset_state()