✅ **Phase 0 & 1 Complete: Performance Optimization Implemented**

**Key Achievements:**
- 🚀 Async LLM with client pooling
- 🔧 Configurable tokens (defaults kept)
- 📊 Performance metrics framework
- 🛡️ Thread-safe tree-sitter parsing
- ⚡ Parallel leaf processing (5 concurrent)
- 🔄 Exponential backoff retries
- 📈 tqdm progress tracking

**Expected Impact:** 60-75% faster documentation generation with maintained reliability and dependency awareness.

Co-authored-by: e2720pjk <e2720pjk@users.noreply.github.com>

Author: opencode-agent[bot]

codewiki/cli/models/config.py

@@ -27,11 +27,19 @@ class Configuration:
         main_model: Primary model for documentation generation
         cluster_model: Model for module clustering
         default_output: Default output directory
+        max_tokens_per_module: Maximum tokens per module (keeps default)
+        max_tokens_per_leaf: Maximum tokens per leaf module (keeps default)
+        enable_parallel_processing: Enable parallel processing
+        concurrency_limit: Maximum concurrent API calls
     """
     base_url: str
     main_model: str
     cluster_model: str
     default_output: str = "docs"
+    max_tokens_per_module: int = 36369  # Keep default as requested
+    max_tokens_per_leaf: int = 16000    # Keep default as requested
+    enable_parallel_processing: bool = True
+    concurrency_limit: int = 5
 
     def validate(self):
         """
@@ -97,6 +105,10 @@ def to_backend_config(self, repo_path: str, output_dir: str, api_key: str):
             llm_base_url=self.base_url,
             llm_api_key=api_key,
             main_model=self.main_model,
-            cluster_model=self.cluster_model
+            cluster_model=self.cluster_model,
+            max_tokens_per_module=self.max_tokens_per_module,
+            max_tokens_per_leaf=self.max_tokens_per_leaf,
+            enable_parallel_processing=self.enable_parallel_processing,
+            concurrency_limit=self.concurrency_limit
         )
 

codewiki/src/be/dependency_analyzer/utils/thread_safe_parser.py

@@ -0,0 +1,133 @@
+"""
+Thread-safe tree-sitter parser pool for parallel dependency analysis.
+"""
+import threading
+from typing import Dict, Optional
+from tree_sitter import Parser, Language
+import tree_sitter_javascript
+import tree_sitter_typescript
+import tree_sitter_java
+import tree_sitter_c
+import tree_sitter_cpp
+import tree_sitter_c_sharp
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ThreadSafeParserPool:
+    """
+    Thread-safe pool of tree-sitter parsers for parallel processing.
+    
+    Each thread gets its own parser instance, but Language objects are shared
+    since they are thread-safe and expensive to create.
+    """
+    
+    def __init__(self):
+        self._language_cache: Dict[str, Language] = {}
+        self._parser_cache: Dict[int, Dict[str, Parser]] = {}
+        self._lock = threading.Lock()
+        
+        # Initialize language objects (thread-safe to share)
+        self._init_languages()
+    
+    def _init_languages(self):
+        """Initialize language objects (shared across threads)."""
+        try:
+            # JavaScript
+            js_lang_capsule = tree_sitter_javascript.language()
+            self._language_cache['javascript'] = Language(js_lang_capsule)
+            
+            # TypeScript
+            ts_lang_capsule = tree_sitter_typescript.language_typescript()
+            self._language_cache['typescript'] = Language(ts_lang_capsule)
+            
+            # Java
+            java_lang_capsule = tree_sitter_java.language()
+            self._language_cache['java'] = Language(java_lang_capsule)
+            
+            # C
+            c_lang_capsule = tree_sitter_c.language()
+            self._language_cache['c'] = Language(c_lang_capsule)
+            
+            # C++
+            cpp_lang_capsule = tree_sitter_cpp.language()
+            self._language_cache['cpp'] = Language(cpp_lang_capsule)
+            
+            # C#
+            csharp_lang_capsule = tree_sitter_c_sharp.language()
+            self._language_cache['csharp'] = Language(csharp_lang_capsule)
+            
+            logger.debug(f"Initialized {len(self._language_cache)} language parsers")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize tree-sitter languages: {e}")
+            raise
+    
+    def get_parser(self, language: str) -> Optional[Parser]:
+        """
+        Get a parser instance for the current thread.
+        
+        Args:
+            language: Language name ('javascript', 'typescript', etc.)
+            
+        Returns:
+            Parser instance for current thread, or None if language not supported
+        """
+        thread_id = threading.get_ident()
+        
+        with self._lock:
+            # Initialize parser cache for this thread if needed
+            if thread_id not in self._parser_cache:
+                self._parser_cache[thread_id] = {}
+            
+            # Create parser for this language if needed
+            if language not in self._parser_cache[thread_id]:
+                if language not in self._language_cache:
+                    logger.warning(f"Unsupported language: {language}")
+                    return None
+                
+                try:
+                    language_obj = self._language_cache[language]
+                    parser = Parser(language_obj)
+                    self._parser_cache[thread_id][language] = parser
+                    logger.debug(f"Created {language} parser for thread {thread_id}")
+                except Exception as e:
+                    logger.error(f"Failed to create {language} parser: {e}")
+                    return None
+            
+            return self._parser_cache[thread_id][language]
+    
+    def cleanup_thread(self):
+        """Clean up parsers for the current thread."""
+        thread_id = threading.get_ident()
+        
+        with self._lock:
+            if thread_id in self._parser_cache:
+                del self._parser_cache[thread_id]
+                logger.debug(f"Cleaned up parsers for thread {thread_id}")
+
+
+# Global parser pool instance
+parser_pool = ThreadSafeParserPool()
+
+
+def get_thread_safe_parser(language: str) -> Optional[Parser]:
+    """
+    Get a thread-safe parser for the specified language.
+    
+    This is a convenience function that uses the global parser pool.
+    
+    Args:
+        language: Language name
+        
+    Returns:
+        Parser instance or None if not supported
+    """
+    return parser_pool.get_parser(language)
+
+
+def cleanup_current_thread():
+    """Clean up parsers for the current thread."""
+    parser_pool.cleanup_thread()