v3.3.0: Add clarifying questions before planning

Dockerfile

@@ -1,5 +1,5 @@
 # HuggingFace Spaces Dockerfile for CodePilot
-# BUILD_VERSION: 8 (v3.2.1 coder max 8 iterations)
+# BUILD_VERSION: 9 (v3.3.0 clarifying questions)
 FROM python:3.11-slim
 
 # Set working directory

chainlit_app.py

@@ -20,8 +20,8 @@ from concurrent.futures import ThreadPoolExecutor
 # ============================================================
 # STARTUP VERSION CHECK - Change this to detect if rebuild worked
 # ============================================================
-APP_VERSION = "3.2.1-coder-max8"
-BUILD_ID = "2024-12-19-v7"
+APP_VERSION = "3.3.0-clarify"
+BUILD_ID = "2024-12-19-v8"
 print("=" * 60)
 print(f"[STARTUP] CodePilot Chainlit App")
 print(f"[STARTUP] APP_VERSION: {APP_VERSION}")
@@ -121,6 +121,83 @@ async def main(message: cl.Message):
     # Get orchestrator
     orchestrator: Orchestrator = cl.user_session.get("orchestrator")
 
+    # Check if we're waiting for clarification answers
+    if cl.user_session.get("waiting_for_clarification"):
+        cl.user_session.set("waiting_for_clarification", False)
+        user_answers = message.content
+
+        await cl.Message(content="Got it! Let me create the plan with your clarifications...").send()
+
+        # Resume the orchestrator with user answers
+        log_msg = cl.Message(content="")
+        await log_msg.send()
+
+        try:
+            captured_output = io.StringIO()
+
+            def resume_orchestrator():
+                with redirect_stdout(captured_output), redirect_stderr(captured_output):
+                    return orchestrator.resume_after_clarification(user_answers)
+
+            loop = asyncio.get_event_loop()
+            executor = ThreadPoolExecutor(max_workers=1)
+            future = loop.run_in_executor(executor, resume_orchestrator)
+
+            # Track tokens
+            total_prompt_tokens = 0
+            total_completion_tokens = 0
+            total_tokens = 0
+            seen_token_lines = set()
+
+            # Stream logs
+            accumulated_logs = ""
+            while not future.done():
+                await asyncio.sleep(0.5)
+                current_output = captured_output.getvalue()
+                if current_output != accumulated_logs:
+                    accumulated_logs = current_output
+                    filtered_lines = []
+                    for line in accumulated_logs.split('\n'):
+                        if 'Tokens:' in line and line not in seen_token_lines:
+                            seen_token_lines.add(line)
+                            try:
+                                parts = line.split('Tokens:')[1].strip()
+                                prompt = int(parts.split('prompt')[0].strip())
+                                completion = int(parts.split('+')[1].split('completion')[0].strip())
+                                total_prompt_tokens += prompt
+                                total_completion_tokens += completion
+                                total_tokens += (prompt + completion)
+                            except:
+                                pass
+                        if any(skip in line for skip in ['Tokens:', 'Batches:', '|##', 'it/s]']):
+                            continue
+                        if any(keep in line for keep in [
+                            '[CLASSIFIER]', '[ORCHESTRATOR]', '[PLANNER]', '[CODER]', '[REVIEWER]',
+                            '[EXPLORER]', 'Calling tool:', 'Transitioning', 'APPROVED', 'REJECTED'
+                        ]):
+                            filtered_lines.append(line)
+                    filtered_output = '\n'.join(filtered_lines)
+                    input_cost = (total_prompt_tokens / 1000000) * 3.0
+                    output_cost = (total_completion_tokens / 1000000) * 15.0
+                    total_cost = input_cost + output_cost
+                    usage_summary = f"\n\nCREDITS: ${total_cost:.4f}"
+                    log_msg.content = f"```\n{filtered_output}{usage_summary}\n```"
+                    await log_msg.update()
+
+            result = await future
+            # Continue to show results (handled by falling through to normal result handling below)
+            # For now, show summary directly
+            summary = f"## Result\n**Status:** {result.get('status')}\n"
+            if result.get('code_changes'):
+                summary += f"**Files created:** {len(result['code_changes'])}\n"
+            summary += f"**Cost:** ${total_cost:.4f}"
+            await cl.Message(content=summary).send()
+            return
+
+        except Exception as e:
+            await cl.Message(content=f"Error resuming: {str(e)}").send()
+            return
+
     # Check for GitHub URL in message
     github_url = extract_github_url(message.content)
     task_context = ""
@@ -319,6 +396,18 @@ AVAILABLE TOOLS:
         log_msg.content = f"## Execution Log\n```\n{final_logs}\n```"
         await log_msg.update()
 
+        # Check if we need clarification from user
+        if result.get('status') == 'clarifying' and result.get('clarifying_questions'):
+            questions = result['clarifying_questions']
+            # Store that we're waiting for clarification
+            cl.user_session.set("waiting_for_clarification", True)
+
+            await cl.Message(
+                content=f"## Before I proceed, I have some questions:\n\n{questions}\n\n"
+                        f"**Please answer the questions above so I can create a better plan.**"
+            ).send()
+            return  # Wait for user to respond
+
         # Send results summary
         summary_lines = []
 

codepilot/agents/orchestrator.py

@@ -9,7 +9,7 @@ The orchestrator is the "brain" that:
 """
 
 # VERSION CHECK - If you see this, new code is running!
-ORCHESTRATOR_VERSION = "3.2.1-coder-max8"
+ORCHESTRATOR_VERSION = "3.3.0-clarify"
 print(f"[ORCHESTRATOR] ========== LOADING VERSION {ORCHESTRATOR_VERSION} ==========")
 
 from enum import Enum
@@ -23,7 +23,8 @@ from codepilot.agents.explorer_agent import ExplorerAgent
 
 class AgentState(Enum):
     """Possible states in the multi-agent workflow"""
-    EXPLORING = "exploring"  # NEW - Explorer gathers context first
+    EXPLORING = "exploring"  # Explorer gathers context first
+    CLARIFYING = "clarifying"  # NEW - Ask user clarifying questions
     PLANNING = "planning"
     CODING = "coding"
     REVIEWING = "reviewing"
@@ -39,7 +40,9 @@ class TaskContext:
     Think of this as a clipboard that agents write to and read from.
     """
     task_description: str  # Original task from user
-    exploration_context: Optional[str] = None  # NEW - Created by Explorer
+    exploration_context: Optional[str] = None  # Created by Explorer
+    clarifying_questions: Optional[str] = None  # NEW - Questions from Planner
+    user_answers: Optional[str] = None  # NEW - User's answers to questions
     plan: Optional[str] = None  # Created by Planner (uses exploration_context)
     code_changes: Optional[Dict[str, str]] = None  # Created by Coder
     review_feedback: Optional[str] = None  # Created by Reviewer
@@ -238,20 +241,21 @@ class Orchestrator:
 
     def _run_full_workflow(self, task: str) -> Dict[str, Any]:
         """
-        Run the full Explorer → Planner → Coder → Reviewer workflow.
+        Run the full Explorer → Clarify → Planner → Coder → Reviewer workflow.
 
-        v3.0: Now starts with Explorer to gather context efficiently,
-        then Planner creates plan based on exploration (no tools).
+        v3.3: Now includes clarification step before planning.
 
         Args:
             task: User's task description
 
         Returns:
             Result dict with status, changes, and messages
+            If questions need to be asked, returns with state='clarifying'
         """
-        # Initialize context
-        self.context = TaskContext(task_description=task)
-        self.state = AgentState.EXPLORING  # v3.0: Start with EXPLORING
+        # Initialize context if not already done
+        if self.context is None:
+            self.context = TaskContext(task_description=task)
+            self.state = AgentState.EXPLORING
 
         # Main state machine loop
         while self.state not in [AgentState.COMPLETE, AgentState.FAILED]:
@@ -263,7 +267,13 @@ class Orchestrator:
 
             # Execute current state
             if self.state == AgentState.EXPLORING:
-                self._execute_exploring()  # NEW - Explorer first
+                self._execute_exploring()
+
+            elif self.state == AgentState.CLARIFYING:
+                self._execute_clarifying()
+                # If questions were generated, pause and return to Chainlit
+                if self.context.clarifying_questions and self.state == AgentState.CLARIFYING:
+                    return self._build_result()  # Return with questions, Chainlit will resume
 
             elif self.state == AgentState.PLANNING:
                 self._execute_planning()
@@ -279,6 +289,19 @@ class Orchestrator:
         # Return final result
         return self._build_result()
 
+    def resume_after_clarification(self, user_answers: str) -> Dict[str, Any]:
+        """
+        Resume workflow after user provides answers to clarifying questions.
+
+        Args:
+            user_answers: User's answers to the questions
+
+        Returns:
+            Result dict from continued workflow
+        """
+        self.provide_user_answers(user_answers)
+        return self._run_full_workflow(self.context.task_description)
+
     def _execute_exploring(self):
         """
         Execute exploring state: call Explorer agent to gather context.
@@ -288,7 +311,7 @@ class Orchestrator:
         - Find relevant files, functions, and patterns
         - Return context summary for Planner to use
 
-        Transition: Always go to PLANNING next
+        Transition: Always go to CLARIFYING next
         """
         print(f"\n[ORCHESTRATOR] State: EXPLORING")
         print(f"[ORCHESTRATOR] Running Explorer to gather codebase context...")
@@ -299,9 +322,51 @@ class Orchestrator:
         # Store exploration context for Planner to use
         self.context.exploration_context = exploration_result
 
-        # Transition to planning
+        # Transition to clarifying (ask user questions before planning)
+        self.state = AgentState.CLARIFYING
+        print(f"[ORCHESTRATOR] Exploration complete. Transitioning to CLARIFYING")
+
+    def _execute_clarifying(self):
+        """
+        Execute clarifying state: ask user clarifying questions.
+
+        Planner generates questions, user answers, then we proceed to planning.
+        If no questions needed, skip straight to planning.
+
+        Transition: Go to PLANNING (with or without answers)
+        """
+        print(f"\n[ORCHESTRATOR] State: CLARIFYING")
+        print(f"[ORCHESTRATOR] Generating clarifying questions...")
+
+        # Get clarifying questions from Planner
+        questions = self.planner.get_clarifying_questions(
+            task=self.context.task_description,
+            exploration_context=self.context.exploration_context
+        )
+
+        if questions:
+            # Store questions - Chainlit will handle getting user answers
+            self.context.clarifying_questions = questions
+            print(f"[ORCHESTRATOR] Questions generated. Waiting for user answers...")
+            # Note: We'll pause here and let Chainlit get user input
+            # The state stays at CLARIFYING until user answers are provided
+        else:
+            # No questions needed, go straight to planning
+            print(f"[ORCHESTRATOR] No clarifying questions needed. Transitioning to PLANNING")
+            self.state = AgentState.PLANNING
+
+    def provide_user_answers(self, answers: str):
+        """
+        Provide user answers to clarifying questions and continue workflow.
+
+        Called by Chainlit after user responds to questions.
+
+        Args:
+            answers: User's answers to the clarifying questions
+        """
+        self.context.user_answers = answers
         self.state = AgentState.PLANNING
-        print(f"[ORCHESTRATOR] Exploration complete. Transitioning to PLANNING")
+        print(f"[ORCHESTRATOR] User answers received. Transitioning to PLANNING")
 
     def _execute_planning(self):
         """
@@ -309,18 +374,23 @@ class Orchestrator:
 
         Planner's job (v3.0):
         - Receive exploration context from Explorer
+        - Use user answers if clarifying questions were asked
         - Create step-by-step plan based on exploration (NO TOOLS)
         - Pure LLM reasoning - no searching
 
         Transition: Always go to CODING next
         """
         print(f"\n[ORCHESTRATOR] State: PLANNING")
-        print(f"[ORCHESTRATOR] Using exploration context to create plan (no tools)...")
+        if self.context.user_answers:
+            print(f"[ORCHESTRATOR] Using exploration context + user answers to create plan...")
+        else:
+            print(f"[ORCHESTRATOR] Using exploration context to create plan (no tools)...")
 
-        # Call the Planner with exploration context (v3.0: Planner has no tools)
+        # Call the Planner with exploration context and user answers
         self.context.plan = self.planner.run(
             task=self.context.task_description,
-            exploration_context=self.context.exploration_context
+            exploration_context=self.context.exploration_context,
+            user_answers=self.context.user_answers
         )
 
         # Transition to coding
@@ -403,6 +473,8 @@ class Orchestrator:
             'status': self.state.value,
             'success': self.state == AgentState.COMPLETE,
             'task': self.context.task_description,
+            'clarifying_questions': self.context.clarifying_questions,  # NEW
+            'user_answers': self.context.user_answers,  # NEW
             'plan': self.context.plan,
             'code_changes': self.context.code_changes,
             'review_feedback': self.context.review_feedback,

codepilot/agents/planner_agent.py

@@ -19,6 +19,24 @@ from codepilot.agents.conversation import ConversationManager
 from typing import Optional
 
 
+# Planner's system prompt for asking clarifying questions
+PLANNER_QUESTIONS_PROMPT = """You are a senior software architect helping clarify requirements.
+
+Based on the task and codebase exploration, generate 2-4 SHORT clarifying questions that will help create a better implementation plan.
+
+IMPORTANT:
+- Only ask questions if something is genuinely unclear or there are multiple valid approaches
+- Questions should be answerable in 1-2 sentences
+- Focus on: location, naming, behavior, edge cases
+- If the task is already clear, respond with: "NO_QUESTIONS_NEEDED"
+
+Format your response as a numbered list:
+1. Question one?
+2. Question two?
+
+Or just: NO_QUESTIONS_NEEDED
+"""
+
 # Planner's system prompt (v3.0 - no tools, just planning)
 PLANNER_SYSTEM_PROMPT = """You are a senior software architect and planning expert.
 
@@ -71,7 +89,59 @@ class PlannerAgent:
         else:
             self.client = OpenAIClient(model=model)
 
-    def run(self, task: str, exploration_context: Optional[str] = None) -> str:
+    def get_clarifying_questions(self, task: str, exploration_context: Optional[str] = None) -> Optional[str]:
+        """
+        Generate clarifying questions before creating the plan.
+
+        Args:
+            task: Task description
+            exploration_context: Context gathered by Explorer agent
+
+        Returns:
+            Questions as a string, or None if no questions needed
+        """
+        print(f"[PLANNER] Generating clarifying questions...")
+
+        # Build prompt
+        if exploration_context:
+            user_prompt = f"""=== EXPLORATION RESULTS ===
+{exploration_context}
+
+=== TASK ===
+{task}
+
+Based on the above, what clarifying questions would help create a better implementation plan?
+"""
+        else:
+            user_prompt = f"""=== TASK ===
+{task}
+
+What clarifying questions would help create a better implementation plan?
+"""
+
+        # Create conversation
+        conversation = ConversationManager()
+        conversation.add_message("system", PLANNER_QUESTIONS_PROMPT)
+        conversation.add_message("user", user_prompt)
+
+        # Single LLM call
+        response = self.client.chat(
+            messages=conversation.get_messages(),
+            tools=None,
+            max_tokens=500
+        )
+
+        questions = response.choices[0].message.content
+
+        # Check if questions are needed
+        if questions and "NO_QUESTIONS_NEEDED" in questions.upper():
+            print(f"[PLANNER] No clarifying questions needed")
+            return None
+
+        print(f"[PLANNER] Generated clarifying questions")
+        return questions
+
+    def run(self, task: str, exploration_context: Optional[str] = None, user_answers: Optional[str] = None) -> str:
         """
         Create a plan for the given task using exploration context.
 
@@ -80,6 +150,7 @@ class PlannerAgent:
         Args:
             task: Task description (e.g., "Add login feature")
             exploration_context: Context gathered by Explorer agent
+            user_answers: User's answers to clarifying questions (optional)
 
         Returns:
             Detailed implementation plan as a string
@@ -93,7 +164,15 @@ class PlannerAgent:
 
 === TASK ===
 {task}
+"""
+            # Add user answers if provided
+            if user_answers:
+                user_prompt += f"""
+=== USER CLARIFICATIONS ===
+{user_answers}
+"""
 
+            user_prompt += """
 Based on the exploration results above, create a detailed implementation plan.
 Include specific file paths, function names, and step-by-step instructions for the Coder agent.
 """
@@ -101,7 +180,13 @@ Include specific file paths, function names, and step-by-step instructions for t
             # Fallback if no exploration context (shouldn't happen in v3.0)
             user_prompt = f"""=== TASK ===
 {task}
-
+"""
+            if user_answers:
+                user_prompt += f"""
+=== USER CLARIFICATIONS ===
+{user_answers}
+"""
+            user_prompt += """
 Create a detailed implementation plan for this task.
 Note: No exploration context was provided, so make reasonable assumptions about the codebase structure.
 """