Merge branch 'main' into feat/repo-cards-redesign

Author: DevanshuNEU

backend/requirements.txt

@@ -18,6 +18,7 @@ hiredis>=2.3.0
 tree-sitter>=0.23.0
 tree-sitter-python>=0.23.0
 tree-sitter-javascript>=0.23.0
+tree-sitter-typescript>=0.23.0
 
 # AI/ML
 openai>=1.54.0

backend/routes/analysis.py

@@ -21,19 +21,21 @@ class ImpactRequest(BaseModel):
 @router.get("/{repo_id}/dependencies")
 async def get_dependency_graph(
     repo_id: str,
+    force: bool = False,
     auth: AuthContext = Depends(require_auth)
 ):
-    """Get dependency graph for repository."""
+    """Get dependency graph for repository. Use force=true to rebuild from scratch."""
     try:
         repo = get_repo_or_404(repo_id, auth.user_id)
 
-        cached_graph = dependency_analyzer.load_from_cache(repo_id)
-        if cached_graph:
-            logger.debug("Using cached dependency graph", repo_id=repo_id)
-            return {**cached_graph, "cached": True}
+        if not force:
+            cached_graph = dependency_analyzer.load_from_cache(repo_id)
+            if cached_graph:
+                logger.debug("Using cached dependency graph", repo_id=repo_id)
+                return {**cached_graph, "cached": True}
 
-        logger.info("Building fresh dependency graph", repo_id=repo_id)
-        graph_data = dependency_analyzer.build_dependency_graph(repo["local_path"])
+        logger.info("Building fresh dependency graph", repo_id=repo_id, include_paths=repo.get("include_paths"))
+        graph_data = dependency_analyzer.build_dependency_graph(repo["local_path"], include_paths=repo.get("include_paths"))
         dependency_analyzer.save_to_cache(repo_id, graph_data)
 
         return {**graph_data, "cached": False}
@@ -64,7 +66,7 @@ async def analyze_impact(
         graph_data = dependency_analyzer.load_from_cache(repo_id)
         if not graph_data:
             logger.info("Building dependency graph for impact analysis", repo_id=repo_id)
-            graph_data = dependency_analyzer.build_dependency_graph(repo["local_path"])
+            graph_data = dependency_analyzer.build_dependency_graph(repo["local_path"], include_paths=repo.get("include_paths"))
             dependency_analyzer.save_to_cache(repo_id, graph_data)
 
         impact = dependency_analyzer.get_file_impact(
@@ -94,7 +96,7 @@ async def get_repository_insights(
         graph_data = dependency_analyzer.load_from_cache(repo_id)
         if not graph_data:
             logger.info("Building dependency graph for insights", repo_id=repo_id)
-            graph_data = dependency_analyzer.build_dependency_graph(repo["local_path"])
+            graph_data = dependency_analyzer.build_dependency_graph(repo["local_path"], include_paths=repo.get("include_paths"))
             dependency_analyzer.save_to_cache(repo_id, graph_data)
 
         return {

backend/routes/repos.py

@@ -602,6 +602,14 @@ async def _run_async_indexing(
 
         repo_manager.update_status(repo_id, "indexing")
 
+        # Persist include_paths (or clear it if re-indexing full repo)
+        from services.supabase_service import get_supabase_service
+        db = get_supabase_service()
+        db.update_repository(repo_id, {"include_paths": include_paths})
+
+        # Clear stale dependency cache so next graph build uses new include_paths
+        db.clear_file_dependencies(repo_id)
+        
         # Publish initial progress to confirm connection
         if publisher:
             publisher.publish_progress(repo_id, 0, 1, 0, "Starting...")

backend/services/dependency_analyzer.py

@@ -9,6 +9,11 @@
 # Tree-sitter
 import tree_sitter_python as tspython
 import tree_sitter_javascript as tsjavascript
+try:
+    import tree_sitter_typescript as tstypescript
+    _HAS_TS_PARSER = True
+except ModuleNotFoundError:
+    _HAS_TS_PARSER = False
 from tree_sitter import Language, Parser
 
 from services.observability import logger, metrics
@@ -18,13 +23,24 @@ class DependencyAnalyzer:
     """Analyze code dependencies and build dependency graph"""
 
     def __init__(self):
-        # Initialize parsers
+        js_lang = Language(tsjavascript.language())
+        # Use proper TS parser if available, fall back to JS parser
+        if _HAS_TS_PARSER:
+            ts_lang = Language(tstypescript.language_typescript())
+            tsx_lang = Language(tstypescript.language_tsx())
+        else:
+            logger.warning("tree-sitter-typescript not installed, falling back to JS parser for TS/TSX")
+            ts_lang = js_lang
+            tsx_lang = js_lang
+
+        self.has_ts_parser = _HAS_TS_PARSER
         self.parsers = {
             'python': Parser(Language(tspython.language())),
-            'javascript': Parser(Language(tsjavascript.language())),
-            'typescript': Parser(Language(tsjavascript.language())),
+            'javascript': Parser(js_lang),
+            'typescript': Parser(ts_lang),
+            'tsx': Parser(tsx_lang),
         }
-        logger.info("DependencyAnalyzer initialized")
+        logger.info("DependencyAnalyzer initialized", ts_parser=self.has_ts_parser)
 
     def _detect_language(self, file_path: str) -> str:
         """Detect language from file extension"""
@@ -34,7 +50,7 @@ def _detect_language(self, file_path: str) -> str:
             '.js': 'javascript',
             '.jsx': 'javascript',
             '.ts': 'typescript',
-            '.tsx': 'typescript',
+            '.tsx': 'tsx',
         }
         return lang_map.get(ext, 'unknown')
 
@@ -122,10 +138,22 @@ def analyze_file_dependencies(self, file_path: str) -> Dict:
             logger.error("Error analyzing file", file_path=file_path, error=str(e))
             return {"file": str(file_path), "imports": [], "language": language, "error": str(e)}
 
-    def build_dependency_graph(self, repo_path: str) -> Dict:
-        """Build complete dependency graph for repository"""
+    def build_dependency_graph(self, repo_path: str, include_paths: List[str] = None) -> Dict:
+        """Build dependency graph. If include_paths set, only analyze those dirs."""
         repo_path = Path(repo_path)
 
+        # Sanitize include_paths from DB (could be corrupt jsonb)
+        if include_paths:
+            cleaned = []
+            for p in include_paths:
+                if not isinstance(p, str):
+                    continue
+                p = p.replace('\\', '/').strip().strip('/')
+                if not p or '..' in p.split('/'):
+                    continue
+                cleaned.append(p)
+            include_paths = cleaned or None
+        
         # Discover code files
         code_files = []
         extensions = {'.py', '.js', '.jsx', '.ts', '.tsx'}
@@ -136,8 +164,16 @@ def build_dependency_graph(self, repo_path: str) -> Dict:
                 continue
             if any(skip in file_path.parts for skip in skip_dirs):
                 continue
-            if file_path.suffix in extensions:
-                code_files.append(file_path)
+            if file_path.suffix not in extensions:
+                continue
+            if include_paths:
+                rel_parts = file_path.relative_to(repo_path).parts
+                if not any(
+                    rel_parts[:len(Path(p).parts)] == Path(p).parts
+                    for p in include_paths
+                ):
+                    continue
+            code_files.append(file_path)
 
         logger.info("Building dependency graph", file_count=len(code_files))
 
@@ -236,6 +272,10 @@ def _resolve_import_to_file(
         source_path = Path(source_file)
         source_dir = source_path.parent
 
+        # TS imports use .js extension but actual file is .ts on disk
+        if import_path.endswith('.js') or import_path.endswith('.jsx'):
+            import_path = re.sub(r'\.(jsx?)$', '', import_path)
+        
         # Relative imports
         if import_path.startswith('.'):
             clean_import = import_path.lstrip('./')
@@ -250,7 +290,7 @@ def _resolve_import_to_file(
             else:
                 potential_base = source_dir / clean_import
 
-            extensions = ['', '.ts', '.tsx', '.js', '.jsx', '.py']
+            extensions = ['', '.ts', '.tsx', '.d.ts', '.js', '.jsx', '.py']
 
             for ext in extensions:
                 # Build the potential path
@@ -269,7 +309,7 @@ def _resolve_import_to_file(
         if not import_path.startswith('.'):
             module_path = import_path.replace('.', '/')
 
-            for ext in ['.py', '.js', '.ts']:
+            for ext in ['', '.ts', '.tsx', '.d.ts', '.js', '.jsx', '.py']:
                 test_path = module_path + ext
                 if test_path in internal_files:
                     return test_path

backend/services/indexer_optimized.py

@@ -58,30 +58,29 @@ def __init__(self):
         # Initialize search enhancer
         self.search_enhancer = SearchEnhancer(self.openai_client)
 
-        # Initialize Pinecone
-        pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
-        
-        index_name = os.getenv("PINECONE_INDEX_NAME", "codeintel")
-        
-        # Check if index exists and has correct dimensions
-        existing_indexes = pc.list_indexes().names()
-        if index_name in existing_indexes:
-            # Use existing index (dimension already set)
-            index_info = pc.describe_index(index_name)
-            logger.info("Using existing Pinecone index", index=index_name, dimension=index_info.dimension)
-        else:
-            logger.info("Creating Pinecone index", index=index_name, dimension=EMBEDDING_DIMENSIONS)
-            pc.create_index(
-                name=index_name,
-                dimension=EMBEDDING_DIMENSIONS,
-                metric="cosine",
-                spec=ServerlessSpec(
-                    cloud="aws",
-                    region="us-east-1"
+        # Initialize Pinecone (lazy-safe: app starts even if Pinecone is unreachable)
+        self.index = None
+        self._pinecone_index_name = os.getenv("PINECONE_INDEX_NAME", "codeintel")
+        try:
+            pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
+            existing_indexes = pc.list_indexes().names()
+            if self._pinecone_index_name in existing_indexes:
+                index_info = pc.describe_index(self._pinecone_index_name)
+                logger.info("Using existing Pinecone index", index=self._pinecone_index_name, dimension=index_info.dimension)
+            else:
+                logger.info("Creating Pinecone index", index=self._pinecone_index_name, dimension=EMBEDDING_DIMENSIONS)
+                pc.create_index(
+                    name=self._pinecone_index_name,
+                    dimension=EMBEDDING_DIMENSIONS,
+                    metric="cosine",
+                    spec=ServerlessSpec(
+                        cloud="aws",
+                        region="us-east-1"
+                    )
                 )
-            )
-        
-        self.index = pc.Index(index_name)
+            self.index = pc.Index(self._pinecone_index_name)
+        except Exception as e:
+            logger.error("Pinecone initialization failed -- search/indexing unavailable until reconnect", error=str(e))
 
         # Initialize tree-sitter parsers
         self.parsers = {