Update src/main.py

src/main.py

@@ -246,25 +246,33 @@ class CodebaseIndexer:
             if not self.config.PINECONE_API_KEY:
                 raise ValueError("Pinecone API key required")
             
-            # Initialize Pinecone
-            pc = Pinecone(api_key=self.config.PINECONE_API_KEY)
-            
-            # Create index if not exists
-            if self.config.PINECONE_INDEX_NAME not in pc.list_indexes().names():
-                pc.create_index(
-                    name=self.config.PINECONE_INDEX_NAME,
-                    dimension=self.config.EMBEDDING_DIM,
-                    metric="cosine",
-                    spec=ServerlessSpec(
-                        cloud=self.config.PINECONE_CLOUD,
-                        region=self.config.PINECONE_REGION
+            try:
+                # Initialize Pinecone (v5+ syntax)
+                pc = Pinecone(api_key=self.config.PINECONE_API_KEY)
+                
+                # Create index if not exists
+                existing_indexes = pc.list_indexes()
+                index_names = [idx.name for idx in existing_indexes] if hasattr(existing_indexes, '__iter__') else []
+                
+                if self.config.PINECONE_INDEX_NAME not in index_names:
+                    pc.create_index(
+                        name=self.config.PINECONE_INDEX_NAME,
+                        dimension=self.config.EMBEDDING_DIM,
+                        metric="cosine",
+                        spec=ServerlessSpec(
+                            cloud=self.config.PINECONE_CLOUD,
+                            region=self.config.PINECONE_REGION
+                        )
                     )
-                )
-                # Wait for index to be ready
-                time.sleep(5)
-            
-            self._index = pc.Index(self.config.PINECONE_INDEX_NAME)
-            print(f"📂 Pinecone index ready: {self.config.PINECONE_INDEX_NAME}")
+                    # Wait for index to be ready
+                    print(f"⏳ Waiting for index to be ready...")
+                    time.sleep(10)
+                
+                self._index = pc.Index(self.config.PINECONE_INDEX_NAME)
+                print(f"📂 Pinecone index ready: {self.config.PINECONE_INDEX_NAME}")
+            except Exception as e:
+                print(f"❌ Pinecone initialization error: {str(e)}")
+                raise ValueError(f"Failed to initialize Pinecone: {str(e)}")
         
         return self._index
     
@@ -505,30 +513,21 @@ Provide JSON:
             for c in code_context[:5]
         ])
         
-        prompt = f"""Create a detailed implementation strategy for this ticket:
+        prompt = f"""Create implementation strategy:
 
-Ticket Analysis: {json.dumps(ticket_analysis, indent=2)}
+Analysis: {json.dumps(ticket_analysis)}
 
-Relevant Code Context:
+Code Context:
 {context_str}
 
-Provide a comprehensive JSON response with:
+Provide JSON:
 {{
-    "architecture_notes": "Detailed explanation of how this feature fits into the existing architecture",
-    "implementation_steps": ["Step 1: ...", "Step 2: ...", "Step 3: ..."],
-    "files_to_modify": [
-        {{
-            "path": "relative/path/to/file.py",
-            "action": "create|modify|extend",
-            "reason": "Why this file needs to be changed",
-            "details": "Specific changes needed (functions to add, classes to modify, etc.)"
-        }}
-    ],
-    "patterns_to_follow": ["Pattern 1 from codebase", "Pattern 2 from codebase"],
-    "integration_points": ["Where this integrates with existing code"]
-}}
-
-Be specific about file paths, actions, and implementation details."""
+    "architecture_notes": "how it fits",
+    "implementation_steps": ["step1", "step2"],
+    "files_to_modify": [{{"path": "file", "action": "modify/create", "reason": "why"}}],
+    "patterns_to_follow": ["pattern1"],
+    "integration_points": ["point1"]
+}}"""
 
         response = self.client.chat.completions.create(
             model=self.model,
@@ -569,56 +568,25 @@ class DeveloperLLM:
         self._client = None
     
     def generate_boilerplate(self, ticket_analysis: Dict, strategy: Dict, code_context: List[Dict]) -> Dict[str, str]:
-        # Include more context from relevant files
-        context_str = "\n".join([
-            f"// File: {c['metadata'].get('file_path', '?')}\n{c['content'][:600]}\n" 
-            for c in code_context[:5]
-        ])
-        
-        files_to_modify = strategy.get('files_to_modify', [])
-        files_info = "\n".join([
-            f"- {f.get('path', 'unknown')}: {f.get('action', 'create')} - {f.get('reason', '')}"
-            for f in files_to_modify[:10]
-        ]) if files_to_modify else "Create new files as needed"
+        context_str = "\n".join([f"// {c['metadata'].get('file_path', '?')}\n{c['content'][:400]}" 
+                                  for c in code_context[:3]])
         
-        patterns = strategy.get('patterns_to_follow', [])
-        patterns_str = "\n".join([f"- {p}" for p in patterns]) if patterns else "Follow existing codebase patterns"
-        
-        prompt = f"""Generate complete, production-ready implementation code for this ticket.
-
-Ticket Summary: {ticket_analysis.get('summary', '')}
-Key Entities: {', '.join(ticket_analysis.get('key_entities', []))}
-Implementation Steps:
-{chr(10).join(f"{i+1}. {step}" for i, step in enumerate(strategy.get('implementation_steps', [])))}
-
-Files to Create/Modify:
-{files_info}
+        prompt = f"""Generate boilerplate code:
 
-Patterns to Follow:
-{patterns_str}
+Summary: {ticket_analysis.get('summary', '')}
+Entities: {ticket_analysis.get('key_entities', [])}
+Steps: {strategy.get('implementation_steps', [])}
 
-Existing Codebase Patterns (for reference):
+Existing patterns:
 {context_str}
 
-IMPORTANT REQUIREMENTS:
-1. Generate COMPLETE, WORKING code - NOT placeholder TODOs or comments
-2. Follow the exact patterns, structure, and style from the existing codebase
-3. Include all necessary imports, error handling, and type hints
-4. Make the code production-ready and functional
-5. For new files, include complete class/function implementations
-6. For modifications, show the complete updated code sections
-7. Use the same coding conventions, naming, and architecture as the existing code
-
-Respond with JSON where keys are file paths and values are complete code:
-{{"path/to/file.py": "complete working code here", "path/to/other.js": "complete working code here"}}
-
-Generate actual implementation code, not TODO comments."""
+Respond with JSON where keys are file paths:
+{{"path/file.py": "# code with TODOs"}}"""
 
         response = self.client.chat.completions.create(
             model=self.model,
             messages=[{"role": "user", "content": prompt}],
-            temperature=0.3,  # Slightly higher for more creative but still consistent code
-            max_tokens=4000  # Allow for longer, more complete code generation
+            temperature=0.2
         )
         
         usage = response.usage
@@ -626,35 +594,10 @@ Generate actual implementation code, not TODO comments."""
         
         content = response.choices[0].message.content
         try:
-            # Clean up markdown code blocks
             content = re.sub(r'^```json?\s*', '', content.strip())
             content = re.sub(r'\s*```$', '', content)
-            code_dict = json.loads(content)
-            
-            # Post-process: Ensure code quality and completeness
-            processed_code = {}
-            for file_path, code in code_dict.items():
-                # Check if code is mostly TODOs (more than 50% TODO lines)
-                lines = code.split('\n')
-                todo_count = sum(1 for line in lines if re.search(r'TODO:', line, re.IGNORECASE))
-                total_lines = len([l for l in lines if l.strip()])
-                
-                if total_lines > 0 and (todo_count / total_lines) > 0.5:
-                    # Code is mostly TODOs - add a note but keep it
-                    processed_code[file_path] = f"# Note: This code contains many TODOs. Please review and implement.\n\n{code}"
-                else:
-                    # Code looks good, return as-is
-                    processed_code[file_path] = code
-            
-            return processed_code
-        except json.JSONDecodeError:
-            # If JSON parsing fails, try to extract code blocks
-            code_blocks = re.findall(r'```(?:\w+)?\n(.*?)```', content, re.DOTALL)
-            if code_blocks:
-                return {"generated_code.txt": code_blocks[0]}
-            return {"generated_code.txt": content}
-        except Exception as e:
-            print(f"Warning: Error processing generated code: {e}")
+            return json.loads(content)
+        except:
             return {"generated_code.txt": content}
     
     def explain_code_context(self, code_context: List[Dict], question: str) -> str: