git-llm-tool 0.1.16__tar.gz → 0.1.18__tar.gz

{git_llm_tool-0.1.16 → git_llm_tool-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: git-llm-tool
-Version: 0.1.16
+Version: 0.1.18
 Summary: AI-powered git commit message and changelog generator
 License: MIT
 Keywords: git,commit,llm,ai,automation,jira,conventional-commits

{git_llm_tool-0.1.16 → git_llm_tool-0.1.18}/git_llm_tool/providers/langchain_base.py

@@ -294,8 +294,9 @@ class LangChainProvider(LlmProvider):
     ) -> str:
         """Manual map-reduce implementation with parallel processing."""
         try:
-            # Improved parallel processing with timeout handling and fallback
-            use_parallel = (self.ollama_llm is not None) or (len(docs) > 1)
+            # 暫時強制使用序列處理來解決並行處理死鎖問題
+            # use_parallel = (self.ollama_llm is not None) or (len(docs) > 1)
+            use_parallel = True  # 強制禁用並行處理
 
             if use_parallel:
                 return self._parallel_map_reduce(docs, jira_ticket, work_hours, **kwargs)
@@ -312,143 +313,131 @@ class LangChainProvider(LlmProvider):
         work_hours: Optional[str] = None,
         **kwargs
     ) -> str:
-        """Parallel map-reduce implementation for faster processing."""
+        """Parallel map-reduce with timeout & cancellation safety."""
         verbose = kwargs.get("verbose", False)
+        per_chunk_timeout = self.config.llm.chunk_processing_timeout or 120  # default 2 min
+        global_timeout = min(600, per_chunk_timeout * 3)  # 10 min max
 
         try:
-            # Map phase: Process chunks in parallel
-            summaries = [""] * len(docs)  # Pre-allocate to maintain order
+            summaries = [""] * len(docs)
+            start_time = time.time()
+
+            # ---------- helper ----------
+            def safe_invoke(fn, timeout: int):
+                """Run a callable with timeout protection."""
+                with ThreadPoolExecutor(max_workers=1) as single_exec:
+                    future = single_exec.submit(fn)
+                    try:
+                        return future.result(timeout=timeout)
+                    except TimeoutError:
+                        future.cancel()
+                        raise TimeoutError(f"LLM call exceeded {timeout}s timeout")
 
+            # ---------- map phase ----------
             def process_chunk(index_doc_pair):
-                """Process a single chunk."""
+                """Process a single chunk with timeout & error guard."""
                 i, doc = index_doc_pair
                 try:
-                    if kwargs.get("verbose", False):
-                        print(f"📝 Processing chunk {i+1}/{len(docs)} in parallel...")
+                    if verbose:
+                        print(f"📝 [Worker] Chunk {i+1}/{len(docs)} started...")
 
-                    # Create map prompt for this chunk
                     map_prompt = self._create_simple_map_prompt(doc.page_content)
 
                     def _make_map_call():
-                        # Use Ollama for chunk processing if available, otherwise use main LLM
                         if self.ollama_llm is not None:
                             return self.ollama_llm.invoke(map_prompt)
                         else:
                             return self.llm.invoke(map_prompt)
 
-                    # Execute with rate limiting
-                    if self.rate_limiter:
-                        response = self.rate_limiter.retry_with_backoff(_make_map_call)
-                    else:
-                        response = _make_map_call()
+                    # Execute with safe timeout + rate limiting
+                    def _wrapped_call():
+                        if self.rate_limiter:
+                            return self.rate_limiter.retry_with_backoff(_make_map_call)
+                        else:
+                            return _make_map_call()
 
-                    # Extract text from response
-                    if hasattr(response, 'content'):
+                    response = safe_invoke(_wrapped_call, per_chunk_timeout)
+
+                    # Extract text
+                    if hasattr(response, "content"):
                         summary = response.content.strip()
                     elif isinstance(response, str):
                         summary = response.strip()
                     else:
                         summary = str(response).strip()
 
-                    if kwargs.get("verbose", False):
-                        print(f"   ✅ Chunk {i+1} completed ({len(summary)} chars)")
+                    if verbose:
+                        print(f"✅ [Worker] Chunk {i+1} done ({len(summary)} chars)")
 
                     return i, summary
 
+                except TimeoutError as e:
+                    return i, f"⏰ Timeout: {e}"
                 except Exception as e:
-                    if kwargs.get("verbose", False):
-                        print(f"   ❌ Chunk {i+1} failed: {e}")
-                    return i, f"Error processing chunk: {str(e)}"
+                    return i, f"❌ Error processing chunk {i+1}: {e}"
 
-            # Execute parallel processing with configurable worker count
+            # Decide worker count
             if self.ollama_llm is not None:
-                # Ollama is local, use configured Ollama concurrency
-                max_workers = min(self.config.llm.ollama_max_parallel_chunks, len(docs))
+                max_workers = min(getattr(self.config.llm, "ollama_max_parallel_chunks", 2), len(docs))
             else:
-                # Remote API, use configured remote API concurrency
-                max_workers = min(self.config.llm.max_parallel_chunks, len(docs))
-            completed_chunks = 0
+                max_workers = min(getattr(self.config.llm, "max_parallel_chunks", 4), len(docs))
 
-            with Halo(text=f"🚀 Starting {max_workers} parallel workers for {len(docs)} chunks...", spinner="dots") as spinner:
-                with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                    # Submit all tasks
-                    future_to_index = {
-                        executor.submit(process_chunk, (i, doc)): i
-                        for i, doc in enumerate(docs)
-                    }
+            print(f"🚀 Launching {max_workers} parallel workers for {len(docs)} chunks...")
 
-                    # Collect results as they complete with reasonable timeout
-                    # Use per-chunk timeout plus some buffer, not total timeout
-                    reasonable_timeout = min(600, self.config.llm.chunk_processing_timeout * 3)  # Max 10 minutes or 3x per-chunk timeout
+            completed_chunks = 0
 
-                    try:
-                        for future in as_completed(future_to_index, timeout=reasonable_timeout):
-                            try:
-                                index, summary = future.result(timeout=30)  # Individual result timeout
-                                summaries[index] = summary
-                                completed_chunks += 1
-
-                                # Update spinner text with progress - show parallel workers in action
-                                progress_percent = (completed_chunks / len(docs)) * 100
-                                spinner.text = f"🚀 Parallel processing: {completed_chunks}/{len(docs)} chunks completed ({progress_percent:.1f}%) [{max_workers} workers]"
-
-                                if verbose and not summary.startswith("Error"):
-                                    spinner.text += f" ✅ Chunk {index+1}"
-
-                            except Exception as e:
-                                # Handle individual chunk failures
-                                index = future_to_index[future]
-                                summaries[index] = f"Chunk processing failed: {str(e)}"
-                                completed_chunks += 1
-
-                                progress_percent = (completed_chunks / len(docs)) * 100
-                                spinner.text = f"🚀 Parallel processing: {completed_chunks}/{len(docs)} chunks completed ({progress_percent:.1f}%) [{max_workers} workers]"
-                                if verbose:
-                                    spinner.text += f" ❌ Chunk {index+1} failed"
-
-                    except Exception as timeout_error:
-                        # Handle global timeout or other as_completed errors
-                        spinner.text = f"⚠️ Parallel processing timeout after {reasonable_timeout}s, collecting partial results..."
-
-                        # Collect any completed futures
-                        for future in future_to_index:
-                            if future.done():
-                                try:
-                                    index, summary = future.result(timeout=1)
-                                    summaries[index] = summary
-                                    completed_chunks += 1
-                                except:
-                                    index = future_to_index[future]
-                                    summaries[index] = f"Timeout or error processing chunk"
-                                    completed_chunks += 1
-                            else:
-                                # Cancel remaining futures
-                                future.cancel()
-                                index = future_to_index[future]
-                                summaries[index] = f"Cancelled due to timeout"
-                                completed_chunks += 1
-
-                successful_chunks = len([s for s in summaries if not s.startswith("Error") and not s.startswith("Chunk processing failed")])
-                spinner.succeed(f"✅ Parallel processing completed with {max_workers} workers: {successful_chunks}/{len(docs)} chunks successful")
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                future_to_index = {
+                    executor.submit(process_chunk, (i, doc)): i for i, doc in enumerate(docs)
+                }
 
-            # Reduce phase: Combine summaries into final commit message
-            with Halo(text=f"🔄 Combining {len(summaries)} summaries into final commit message...", spinner="dots") as spinner:
-                combined_summary = "\n\n".join([f"Part {i+1}: {summary}" for i, summary in enumerate(summaries)])
-                combine_prompt = self._create_combine_prompt(combined_summary, jira_ticket, work_hours)
+                try:
+                    for future in as_completed(future_to_index, timeout=global_timeout):
+                        index = future_to_index[future]
+                        try:
+                            i, summary = future.result(timeout=per_chunk_timeout)
+                            summaries[i] = summary
+                        except TimeoutError:
+                            summaries[index] = "⚠️ Timeout during chunk processing"
+                            future.cancel()
+                        except Exception as e:
+                            summaries[index] = f"⚠️ Exception: {e}"
+
+                        completed_chunks += 1
+                        progress = (completed_chunks / len(docs)) * 100
+                        print(f"Progress: {completed_chunks}/{len(docs)} ({progress:.1f}%)")
+
+                except TimeoutError:
+                    print(f"⚠️ Global timeout ({global_timeout}s) reached — cancelling remaining tasks...")
+                    for f in future_to_index:
+                        if not f.done():
+                            f.cancel()
+
+                executor.shutdown(wait=False, cancel_futures=True)
+
+            # ---------- reduce phase ----------
+            successful_chunks = len([s for s in summaries if not s.startswith("❌")])
+            print(f"✅ Map phase done: {successful_chunks}/{len(docs)} chunks successful")
+
+            combined_summary = "\n\n".join(
+                [f"Part {i+1}: {summary}" for i, summary in enumerate(summaries)]
+            )
+            combine_prompt = self._create_combine_prompt(combined_summary, jira_ticket, work_hours)
 
-                def _make_combine_call():
-                    return self.llm.invoke(combine_prompt)
+            def _combine_call():
+                return self.llm.invoke(combine_prompt)
 
-                # Execute final combination with rate limiting
-                if self.rate_limiter:
-                    final_response = self.rate_limiter.retry_with_backoff(_make_combine_call)
-                else:
-                    final_response = _make_combine_call()
+            print("🔄 Combining summaries...")
+            if self.rate_limiter:
+                final_response = self.rate_limiter.retry_with_backoff(
+                    lambda: safe_invoke(_combine_call, 120)
+                )
+            else:
+                final_response = safe_invoke(_combine_call, 120)
 
-                spinner.succeed("✅ Final commit message generated successfully")
+            print("✅ Final commit message generated")
 
-            # Extract final result
-            if hasattr(final_response, 'content'):
+            if hasattr(final_response, "content"):
                 return final_response.content.strip()
             elif isinstance(final_response, str):
                 return final_response.strip()
@@ -456,9 +445,8 @@ class LangChainProvider(LlmProvider):
                 return str(final_response).strip()
 
         except Exception as e:
-            if kwargs.get("verbose", False):
+            if verbose:
                 print(f"❌ Parallel processing failed ({type(e).__name__}: {e}), falling back to sequential...")
-            # Clear any partial results and use sequential fallback
             return self._sequential_map_reduce(docs, jira_ticket, work_hours, **kwargs)
 
     def _sequential_map_reduce(

{git_llm_tool-0.1.16 → git_llm_tool-0.1.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "git-llm-tool"
-version = "0.1.16"
+version = "0.1.18"
 description = "AI-powered git commit message and changelog generator"
 authors = ["skyler-gogolook <skyler.lo@gogolook.com>"]
 readme = "README.md"