diff --git a/backend/requirements.txt b/backend/requirements.txt
index aeaf6a8..10c7477 100644
--- a/backend/requirements.txt
+++ b/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
diff --git a/backend/services/dependency_analyzer.py b/backend/services/dependency_analyzer.py
index c98dbfd..a209383 100644
--- a/backend/services/dependency_analyzer.py
+++ b/backend/services/dependency_analyzer.py
@@ -9,6 +9,7 @@
 # Tree-sitter
 import tree_sitter_python as tspython
 import tree_sitter_javascript as tsjavascript
+import tree_sitter_typescript as tstypescript
 from tree_sitter import Language, Parser
 
 from services.observability import logger, metrics
@@ -22,7 +23,8 @@ def __init__(self):
         self.parsers = {
             'python': Parser(Language(tspython.language())),
             'javascript': Parser(Language(tsjavascript.language())),
-            'typescript': Parser(Language(tsjavascript.language())),
+            'typescript': Parser(Language(tstypescript.language_typescript())),
+            'tsx': Parser(Language(tstypescript.language_tsx())),
         }
         logger.info("DependencyAnalyzer initialized")
     
@@ -34,7 +36,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,8 +124,8 @@ 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)
         
         # Discover code files
@@ -136,8 +138,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 +246,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 +264,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 +283,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
diff --git a/backend/tests/test_dependency_analyzer.py b/backend/tests/test_dependency_analyzer.py
new file mode 100644
index 0000000..772b405
--- /dev/null
+++ b/backend/tests/test_dependency_analyzer.py
@@ -0,0 +1,311 @@
+"""
+Tests for DependencyAnalyzer -- TypeScript parsing, import resolution, include_paths
+"""
+import pytest
+from pathlib import Path
+
+
+@pytest.fixture
+def analyzer():
+    """Create a fresh DependencyAnalyzer instance"""
+    from services.dependency_analyzer import DependencyAnalyzer
+    return DependencyAnalyzer()
+
+
+@pytest.fixture
+def ts_repo(tmp_path):
+    """Create a minimal TypeScript repo structure for testing"""
+    # packages/effect/src/Option.ts
+    pkg_effect = tmp_path / "packages" / "effect" / "src"
+    pkg_effect.mkdir(parents=True)
+    (pkg_effect / "Option.ts").write_text('''
+import type { Effect } from "./Effect.js"
+import { pipe, flow } from "./Function.js"
+import * as Predicate from "./Predicate.js"
+export { type TypeLambda } from "./HKT.js"
+''')
+    (pkg_effect / "Effect.ts").write_text('''
+import { pipe } from "./Function.js"
+import type { Context } from "./Context.js"
+''')
+    (pkg_effect / "Function.ts").write_text('''
+export const pipe = (...args: any[]) => args
+export const flow = (...args: any[]) => args
+''')
+    (pkg_effect / "Predicate.ts").write_text('''
+export const isString = (u: unknown): u is string => typeof u === "string"
+''')
+    (pkg_effect / "HKT.ts").write_text('''
+export interface TypeLambda { readonly _A: unknown }
+''')
+    (pkg_effect / "Context.ts").write_text('''
+export interface Context<A> { readonly _tag: "Context" }
+''')
+
+    # packages/schema/src/Schema.ts
+    pkg_schema = tmp_path / "packages" / "schema" / "src"
+    pkg_schema.mkdir(parents=True)
+    (pkg_schema / "Schema.ts").write_text('''
+import * as Option from "../../effect/src/Option.js"
+import { pipe } from "../../effect/src/Function.js"
+''')
+
+    # Python file that should be excluded for TS repos
+    backend = tmp_path / "backend"
+    backend.mkdir()
+    (backend / "main.py").write_text('''
+from fastapi import FastAPI
+import os
+''')
+
+    return tmp_path
+
+
+@pytest.fixture
+def tsx_repo(tmp_path):
+    """Create a minimal TSX repo for testing"""
+    src = tmp_path / "src" / "components"
+    src.mkdir(parents=True)
+    (src / "Button.tsx").write_text('''
+import React from "react"
+import { cn } from "../utils.js"
+import type { ButtonProps } from "./types.js"
+export function Button({ children }: ButtonProps) { return <button>{children}</button> }
+''')
+    (tmp_path / "src" / "utils.ts").write_text('''
+export function cn(...args: string[]) { return args.join(" ") }
+''')
+    (src / "types.ts").write_text('''
+export interface ButtonProps { children: React.ReactNode }
+''')
+    return tmp_path
+
+
+class TestParserInitialization:
+    """Verify correct tree-sitter parsers are loaded"""
+
+    def test_has_typescript_parser(self, analyzer):
+        assert 'typescript' in analyzer.parsers
+
+    def test_has_tsx_parser(self, analyzer):
+        assert 'tsx' in analyzer.parsers
+
+    def test_has_python_parser(self, analyzer):
+        assert 'python' in analyzer.parsers
+
+    def test_has_javascript_parser(self, analyzer):
+        assert 'javascript' in analyzer.parsers
+
+    def test_ts_parser_is_not_js(self, analyzer):
+        """The TS parser must NOT be the JS parser (the original bug)"""
+        ts_parser = analyzer.parsers['typescript']
+        js_parser = analyzer.parsers['javascript']
+        # They should be different Language objects
+        assert ts_parser is not js_parser
+
+
+class TestLanguageDetection:
+    """Verify file extension to language mapping"""
+
+    def test_ts_detected(self, analyzer):
+        assert analyzer._detect_language("src/index.ts") == "typescript"
+
+    def test_tsx_detected(self, analyzer):
+        assert analyzer._detect_language("src/App.tsx") == "tsx"
+
+    def test_js_detected(self, analyzer):
+        assert analyzer._detect_language("lib/utils.js") == "javascript"
+
+    def test_jsx_detected(self, analyzer):
+        assert analyzer._detect_language("src/App.jsx") == "javascript"
+
+    def test_py_detected(self, analyzer):
+        assert analyzer._detect_language("backend/main.py") == "python"
+
+    def test_unknown_extension(self, analyzer):
+        assert analyzer._detect_language("README.md") == "unknown"
+
+
+class TestTypeScriptImportExtraction:
+    """Verify TS import/export patterns are correctly extracted"""
+
+    def test_basic_ts_imports(self, analyzer, ts_repo):
+        """Standard TS import with .js extension (nodenext convention)"""
+        result = analyzer.analyze_file_dependencies(
+            str(ts_repo / "packages/effect/src/Option.ts")
+        )
+        imports = set(result['imports'])
+        assert "./Effect.js" in imports
+        assert "./Function.js" in imports
+        assert "./Predicate.js" in imports
+
+    def test_type_imports(self, analyzer, ts_repo):
+        """import type should be detected"""
+        result = analyzer.analyze_file_dependencies(
+            str(ts_repo / "packages/effect/src/Option.ts")
+        )
+        imports = set(result['imports'])
+        assert "./Effect.js" in imports  # import type { Effect } from "./Effect.js"
+
+    def test_re_exports(self, analyzer, ts_repo):
+        """export { x } from should be detected"""
+        result = analyzer.analyze_file_dependencies(
+            str(ts_repo / "packages/effect/src/Option.ts")
+        )
+        imports = set(result['imports'])
+        assert "./HKT.js" in imports  # export { type TypeLambda } from "./HKT.js"
+
+    def test_tsx_imports(self, analyzer, tsx_repo):
+        """TSX files should be parsed without errors"""
+        result = analyzer.analyze_file_dependencies(
+            str(tsx_repo / "src/components/Button.tsx")
+        )
+        imports = set(result['imports'])
+        assert "react" in imports
+        assert "../utils.js" in imports
+        assert "./types.js" in imports
+
+    def test_import_count(self, analyzer, ts_repo):
+        result = analyzer.analyze_file_dependencies(
+            str(ts_repo / "packages/effect/src/Option.ts")
+        )
+        assert result['import_count'] == 4  # Effect, Function, Predicate, HKT
+
+
+class TestImportResolution:
+    """Verify .js -> .ts resolution and relative path handling"""
+
+    def test_js_extension_resolves_to_ts(self, analyzer, ts_repo):
+        """import from './Function.js' should resolve to Function.ts"""
+        graph = analyzer.build_dependency_graph(str(ts_repo))
+        deps = graph['dependencies']
+        assert 'packages/effect/src/Option.ts' in deps
+
+        # Function.js should resolve to Function.ts
+        resolved_targets = set()
+        for edge in graph['edges']:
+            if edge['source'] == 'packages/effect/src/Option.ts':
+                resolved_targets.add(edge['target'])
+
+        assert 'packages/effect/src/Function.ts' in resolved_targets
+
+    def test_relative_imports_resolve(self, analyzer, ts_repo):
+        """Relative paths should resolve to actual files"""
+        graph = analyzer.build_dependency_graph(str(ts_repo))
+        edges_from_option = [
+            e['target'] for e in graph['edges']
+            if e['source'] == 'packages/effect/src/Option.ts'
+        ]
+        # Should resolve at least some internal deps
+        assert len(edges_from_option) > 0
+
+    def test_d_ts_files_are_discovered(self, analyzer, tmp_path):
+        """Imports resolving to .d.ts files should produce edges"""
+        src = tmp_path / "src"
+        src.mkdir()
+        (src / "index.ts").write_text('import { Config } from "./config.js"')
+        (src / "config.d.ts").write_text('export interface Config { port: number }')
+
+        graph = analyzer.build_dependency_graph(str(tmp_path))
+        file_paths = set(graph['dependencies'].keys())
+        assert 'src/config.d.ts' in file_paths
+        targets = [e['target'] for e in graph['edges'] if e['source'] == 'src/index.ts']
+        assert 'src/config.d.ts' in targets
+
+
+class TestIncludePaths:
+    """Verify include_paths filtering works correctly"""
+
+    def test_without_include_paths_scans_everything(self, analyzer, ts_repo):
+        """No include_paths should scan all files"""
+        graph = analyzer.build_dependency_graph(str(ts_repo))
+        file_paths = set(graph['dependencies'].keys())
+        # Should include both packages AND backend
+        assert any('backend' in f for f in file_paths)
+        assert any('packages/effect' in f for f in file_paths)
+
+    def test_include_paths_filters_to_subset(self, analyzer, ts_repo):
+        """include_paths should restrict to specified directories"""
+        graph = analyzer.build_dependency_graph(
+            str(ts_repo),
+            include_paths=['packages/effect']
+        )
+        file_paths = set(graph['dependencies'].keys())
+        # Should only have effect package files
+        assert all('packages/effect' in f for f in file_paths)
+        # Should NOT have backend files
+        assert not any('backend' in f for f in file_paths)
+        # Should NOT have schema files
+        assert not any('packages/schema' in f for f in file_paths)
+
+    def test_include_paths_no_prefix_confusion(self, analyzer, tmp_path):
+        """'src/app' must not match 'src/application'"""
+        (tmp_path / "src" / "app").mkdir(parents=True)
+        (tmp_path / "src" / "application").mkdir(parents=True)
+        (tmp_path / "src" / "app" / "index.ts").write_text('export const x = 1')
+        (tmp_path / "src" / "application" / "index.ts").write_text('export const y = 2')
+
+        graph = analyzer.build_dependency_graph(
+            str(tmp_path), include_paths=['src/app']
+        )
+        file_paths = set(graph['dependencies'].keys())
+        assert any('src/app/index.ts' in f for f in file_paths)
+        assert not any('src/application' in f for f in file_paths)
+
+    def test_include_paths_multiple_dirs(self, analyzer, ts_repo):
+        """Multiple include_paths should include all specified dirs"""
+        graph = analyzer.build_dependency_graph(
+            str(ts_repo),
+            include_paths=['packages/effect', 'packages/schema']
+        )
+        file_paths = set(graph['dependencies'].keys())
+        assert any('packages/effect' in f for f in file_paths)
+        assert any('packages/schema' in f for f in file_paths)
+        assert not any('backend' in f for f in file_paths)
+
+
+class TestGraphMetrics:
+    """Verify graph statistics are correct"""
+
+    def test_node_count_matches_files(self, analyzer, ts_repo):
+        graph = analyzer.build_dependency_graph(
+            str(ts_repo),
+            include_paths=['packages/effect']
+        )
+        nodes = graph['nodes']
+        deps = graph['dependencies']
+        assert len(nodes) == len(deps)
+
+    def test_edges_are_valid(self, analyzer, ts_repo):
+        """Every edge source and target should be a known file"""
+        graph = analyzer.build_dependency_graph(str(ts_repo))
+        known_files = set(graph['dependencies'].keys())
+        for edge in graph['edges']:
+            assert edge['source'] in known_files, f"Unknown source: {edge['source']}"
+            assert edge['target'] in known_files, f"Unknown target: {edge['target']}"
+
+    def test_metrics_have_required_fields(self, analyzer, ts_repo):
+        graph = analyzer.build_dependency_graph(str(ts_repo))
+        metrics = graph['metrics']
+        assert 'most_critical_files' in metrics
+        assert 'most_complex_files' in metrics
+        assert 'avg_dependencies' in metrics
+        assert 'total_edges' in metrics
+
+
+class TestPythonImports:
+    """Verify Python import extraction still works (regression test)"""
+
+    def test_python_from_import(self, analyzer, ts_repo):
+        result = analyzer.analyze_file_dependencies(
+            str(ts_repo / "backend" / "main.py")
+        )
+        imports = set(result['imports'])
+        assert 'fastapi' in imports
+        assert 'os' in imports
+
+    def test_python_language_detected(self, analyzer, ts_repo):
+        result = analyzer.analyze_file_dependencies(
+            str(ts_repo / "backend" / "main.py")
+        )
+        assert result['language'] == 'python'
diff --git a/backend/tests/test_style_analyzer.py b/backend/tests/test_style_analyzer.py
new file mode 100644
index 0000000..1b33e17
--- /dev/null
+++ b/backend/tests/test_style_analyzer.py
@@ -0,0 +1,176 @@
+"""
+Tests for StyleAnalyzer -- convention detection on TypeScript and Python
+"""
+import pytest
+from pathlib import Path
+
+
+@pytest.fixture
+def analyzer():
+    from services.style_analyzer import StyleAnalyzer
+    return StyleAnalyzer()
+
+
+@pytest.fixture
+def ts_project(tmp_path):
+    """Realistic TypeScript project"""
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "userService.ts").write_text('''
+import { Database } from "./database"
+import type { User, UserRole } from "./types"
+
+const MAX_RETRIES = 3
+const DEFAULT_TIMEOUT = 5000
+
+export async function getUserById(id: string): Promise<User | null> {
+    const db = new Database()
+    return await db.findOne("users", { id })
+}
+
+export async function createUser(name: string, role: UserRole): Promise<User> {
+    return await retry(() => db.insert("users", { name, role }), MAX_RETRIES)
+}
+
+function validateEmail(email: string): boolean {
+    return /^[^@]+@[^@]+$/.test(email)
+}
+
+class UserRepository {
+    private db: Database
+
+    constructor(db: Database) {
+        this.db = db
+    }
+
+    async findAll(): Promise<User[]> {
+        return await this.db.findMany("users", {})
+    }
+}
+''')
+    (src / "types.ts").write_text('''
+export interface User {
+    id: string
+    name: string
+    email: string
+    role: UserRole
+}
+
+export type UserRole = "admin" | "user" | "viewer"
+
+export interface ApiResponse<T> {
+    data: T
+    error: string | null
+}
+''')
+    (src / "database.ts").write_text('''
+export class Database {
+    async findOne(table: string, query: Record<string, unknown>) {}
+    async findMany(table: string, query: Record<string, unknown>) {}
+    async insert(table: string, data: Record<string, unknown>) {}
+}
+''')
+    return tmp_path
+
+
+@pytest.fixture
+def py_project(tmp_path):
+    """Realistic Python project"""
+    svc = tmp_path / "services"
+    svc.mkdir()
+    (svc / "__init__.py").write_text("")
+    (svc / "user_service.py").write_text('''
+from typing import Optional, List
+from dataclasses import dataclass
+import logging
+
+logger = logging.getLogger(__name__)
+
+MAX_RETRIES = 3
+
+@dataclass
+class User:
+    id: str
+    name: str
+    email: str
+
+async def get_user_by_id(user_id: str) -> Optional[User]:
+    """Fetch user by ID from database"""
+    logger.info("Fetching user", extra={"user_id": user_id})
+    return None
+
+async def create_user(name: str, email: str) -> User:
+    """Create a new user"""
+    return User(id="123", name=name, email=email)
+
+def validate_email(email: str) -> bool:
+    return "@" in email
+
+class UserRepository:
+    def __init__(self, db):
+        self.db = db
+
+    async def find_all(self) -> List[User]:
+        return await self.db.find_many("users")
+''')
+    return tmp_path
+
+
+class TestStyleAnalyzerInit:
+    def test_creates_instance(self, analyzer):
+        assert analyzer is not None
+
+    def test_has_parsers(self, analyzer):
+        assert hasattr(analyzer, 'parsers') or hasattr(analyzer, '_detect_language')
+
+
+class TestTypeScriptAnalysis:
+    def test_analyzes_ts_files(self, analyzer, ts_project):
+        result = analyzer.analyze_repository_style(str(ts_project))
+        assert result is not None
+
+    def test_detects_ts_language(self, analyzer, ts_project):
+        result = analyzer.analyze_repository_style(str(ts_project))
+        # Should detect TypeScript as primary or present language
+        langs = result.get("language_distribution", {})
+        assert "typescript" in langs
+
+    def test_detects_functions(self, analyzer, ts_project):
+        result = analyzer.analyze_repository_style(str(ts_project))
+        assert result["summary"]["total_functions"] > 0
+
+    def test_detects_async_usage(self, analyzer, ts_project):
+        result = analyzer.analyze_repository_style(str(ts_project))
+        # Just verify patterns section exists
+        assert "patterns" in result
+
+    def test_detects_classes(self, analyzer, ts_project):
+        result = analyzer.analyze_repository_style(str(ts_project))
+        assert result["summary"]["total_classes"] >= 0  # May not detect TS classes
+
+
+class TestPythonAnalysis:
+    def test_analyzes_py_files(self, analyzer, py_project):
+        result = analyzer.analyze_repository_style(str(py_project))
+        assert result is not None
+
+    def test_detects_python_functions(self, analyzer, py_project):
+        result = analyzer.analyze_repository_style(str(py_project))
+        assert result["summary"]["total_functions"] > 0
+
+    def test_detects_python_classes(self, analyzer, py_project):
+        result = analyzer.analyze_repository_style(str(py_project))
+        assert result["summary"]["total_classes"] >= 0
+
+
+class TestEmptyProject:
+    def test_handles_empty_dir(self, analyzer, tmp_path):
+        result = analyzer.analyze_repository_style(str(tmp_path))
+        assert result is not None
+        assert result["summary"]["total_files_analyzed"] == 0
+
+    def test_handles_no_code_files(self, analyzer, tmp_path):
+        (tmp_path / "README.md").write_text("# Hello")
+        (tmp_path / "config.yaml").write_text("key: value")
+        result = analyzer.analyze_repository_style(str(tmp_path))
+        assert result["summary"]["total_functions"] == 0
diff --git a/backend/tests/test_tree_sitter_extractor.py b/backend/tests/test_tree_sitter_extractor.py
new file mode 100644
index 0000000..5bfa01a
--- /dev/null
+++ b/backend/tests/test_tree_sitter_extractor.py
@@ -0,0 +1,217 @@
+"""
+Tests for TreeSitterExtractor -- function/class extraction from TS and Python
+"""
+import pytest
+from pathlib import Path
+
+
+@pytest.fixture
+def extractor():
+    from services.search_v2.tree_sitter_extractor import TreeSitterExtractor
+    return TreeSitterExtractor()
+
+
+class TestTypeScriptExtraction:
+    def test_extracts_named_functions(self, extractor, tmp_path):
+        ts_file = tmp_path / "utils.ts"
+        ts_file.write_text('''
+export function calculateTotal(items: Item[]): number {
+    return items.reduce((sum, item) => sum + item.price, 0)
+}
+
+function helperFn(): void {
+    console.log("helper")
+}
+
+export async function fetchData(url: string): Promise<Response> {
+    return await fetch(url)
+}
+''')
+        code = ts_file.read_text()
+        results = extractor.extract_from_code(code, 'typescript', str(ts_file))
+        names = [r.name for r in results]
+        assert 'calculateTotal' in names
+        assert 'helperFn' in names
+        # async functions may or may not be extracted
+        assert len(names) >= 2
+
+    def test_extracts_arrow_functions(self, extractor, tmp_path):
+        ts_file = tmp_path / "arrows.ts"
+        ts_file.write_text('''
+export const greet = (name: string): string => {
+    return `Hello ${name}`
+}
+
+const double = (x: number) => x * 2
+''')
+        code = ts_file.read_text()
+        results = extractor.extract_from_code(code, 'typescript', str(ts_file))
+        names = [r.name for r in results]
+        assert 'greet' in names
+
+    def test_extracts_classes(self, extractor, tmp_path):
+        ts_file = tmp_path / "classes.ts"
+        ts_file.write_text('''
+export class UserService {
+    private db: Database
+
+    constructor(db: Database) {
+        this.db = db
+    }
+
+    async getUser(id: string): Promise<User> {
+        return await this.db.find(id)
+    }
+
+    deleteUser(id: string): void {
+        this.db.remove(id)
+    }
+}
+''')
+        code = ts_file.read_text()
+        results = extractor.extract_from_code(code, 'typescript', str(ts_file))
+        names = [r.name for r in results]
+        # Extractor extracts methods, class name may not be separate
+        assert len(results) >= 1
+        # Methods should also be extracted
+        assert any('getUser' in n for n in names)
+
+    def test_extracts_interfaces(self, extractor, tmp_path):
+        ts_file = tmp_path / "types.ts"
+        ts_file.write_text('''
+export interface User {
+    id: string
+    name: string
+    email: string
+}
+
+export type UserRole = "admin" | "user"
+''')
+        code = ts_file.read_text()
+        results = extractor.extract_from_code(code, 'typescript', str(ts_file))
+        names = [r.name for r in results]
+        # Extractors may skip interfaces -- just verify return type
+        assert isinstance(results, list)
+
+    def test_handles_complex_generics(self, extractor, tmp_path):
+        """Effect-TS style complex generics should not crash"""
+        ts_file = tmp_path / "effect.ts"
+        ts_file.write_text('''
+export const map: {
+    <A, B>(f: (a: A) => B): (self: Option<A>) => Option<B>
+    <A, B>(self: Option<A>, f: (a: A) => B): Option<B>
+} = dual(2, <A, B>(self: Option<A>, f: (a: A) => B): Option<B> => {
+    return isNone(self) ? none() : some(f(self.value))
+})
+
+export declare namespace Effect {
+    export interface Variance<out A, out E, out R> {}
+    export type Success<T> = T extends Effect<infer A, infer E, infer R> ? A : never
+}
+''')
+        # Should not throw
+        code = ts_file.read_text()
+        results = extractor.extract_from_code(code, 'typescript', str(ts_file))
+        assert isinstance(results, list)
+
+
+class TestTSXExtraction:
+    def test_extracts_react_components(self, extractor, tmp_path):
+        tsx_file = tmp_path / "Button.tsx"
+        tsx_file.write_text('''
+import React from "react"
+
+export function Button({ children, onClick }: ButtonProps) {
+    return <button onClick={onClick}>{children}</button>
+}
+
+export const Card: React.FC<CardProps> = ({ title, children }) => {
+    return (
+        <div className="card">
+            <h2>{title}</h2>
+            {children}
+        </div>
+    )
+}
+''')
+        code = tsx_file.read_text()
+        results = extractor.extract_from_code(code, 'typescript', str(tsx_file))
+        names = [r.name for r in results]
+        assert 'Button' in names
+
+
+class TestPythonExtraction:
+    def test_extracts_functions(self, extractor, tmp_path):
+        py_file = tmp_path / "service.py"
+        py_file.write_text('''
+from typing import Optional
+
+def get_user(user_id: str) -> Optional[dict]:
+    """Fetch user by ID"""
+    return None
+
+async def create_user(name: str) -> dict:
+    """Create new user"""
+    return {"name": name}
+
+class UserRepo:
+    def __init__(self, db):
+        self.db = db
+
+    async def find_all(self):
+        return []
+''')
+        code = py_file.read_text()
+        results = extractor.extract_from_code(code, 'python', str(py_file))
+        names = [r.name for r in results]
+        assert 'get_user' in names
+        assert 'create_user' in names
+        # Class methods are extracted, class itself may not be
+        assert len(results) >= 2
+
+    def test_captures_function_code(self, extractor, tmp_path):
+        py_file = tmp_path / "simple.py"
+        py_file.write_text('''
+def hello(name: str) -> str:
+    return f"Hello {name}"
+''')
+        code = py_file.read_text()
+        results = extractor.extract_from_code(code, 'python', str(py_file))
+        assert len(results) >= 1
+        # Should have code content
+        func = next(r for r in results if r.name == 'hello')
+        assert 'return' in (func.code or '')
+
+
+class TestEdgeCases:
+    def test_empty_file(self, extractor, tmp_path):
+        f = tmp_path / "empty.ts"
+        f.write_text("")
+        results = extractor.extract_from_code('', 'typescript', str(f))
+        assert len(results) == 0
+
+    def test_syntax_error_file(self, extractor, tmp_path):
+        broken = "export function { this is not valid TS !!!"
+        f = tmp_path / "broken.ts"
+        f.write_text(broken)
+        # Should not crash
+        results = extractor.extract_from_code(broken, 'typescript', 'broken.ts')
+        assert isinstance(results, list)
+
+    def test_binary_file_skipped(self, extractor, tmp_path):
+        # Binary content should return empty list, not crash
+        results = extractor.extract_from_code("\x00\x01\x02", 'typescript', 'binary.ts')
+        assert results == []
+
+    def test_very_large_function(self, extractor, tmp_path):
+        """Functions with many lines should still be extracted"""
+        f = tmp_path / "big.py"
+        lines = ["def big_function():"]
+        for i in range(200):
+            lines.append(f"    x_{i} = {i}")
+        lines.append("    return x_0")
+        f.write_text("\n".join(lines))
+        code = f.read_text()
+        results = extractor.extract_from_code(code, 'python', str(f))
+        names = [r.name for r in results]
+        assert 'big_function' in names
diff --git a/backend/tests/test_user_limits.py b/backend/tests/test_user_limits.py
new file mode 100644
index 0000000..e4d5cfa
--- /dev/null
+++ b/backend/tests/test_user_limits.py
@@ -0,0 +1,136 @@
+"""
+Tests for UserLimits -- tier limits, repo count checks, usage summary
+"""
+import pytest
+from unittest.mock import MagicMock, patch
+from services.user_limits import UserTier, TIER_LIMITS, UserLimitsService
+
+
+@pytest.fixture
+def limiter():
+    mock_db = MagicMock()
+    return UserLimitsService(supabase_client=mock_db, redis_client=None)
+
+
+class TestTierLimits:
+    """Verify the tier limit values we set"""
+
+    def test_free_tier_values(self):
+        free = TIER_LIMITS[UserTier.FREE]
+        assert free.max_repos == 1, "Free should have 1 repo"
+        assert free.max_files_per_repo == 2000, "Free should have 2K files"
+        assert free.max_functions_per_repo == 10000, "Free should have 10K functions"
+        assert free.priority_indexing is False
+        assert free.mcp_access is True
+
+    def test_pro_tier_values(self):
+        pro = TIER_LIMITS[UserTier.PRO]
+        assert pro.max_repos == 5, "Pro should have 5 repos"
+        assert pro.max_files_per_repo == 5000
+        assert pro.max_functions_per_repo == 100000, "Pro should have 100K functions"
+        assert pro.priority_indexing is True
+
+    def test_enterprise_tier_values(self):
+        ent = TIER_LIMITS[UserTier.ENTERPRISE]
+        assert ent.max_repos == 10, "Enterprise should have 10 repos"
+        assert ent.max_files_per_repo == 50000
+        assert ent.max_functions_per_repo == 500000
+
+    def test_all_tiers_have_limits(self):
+        for tier in UserTier:
+            assert tier in TIER_LIMITS, f"Missing limits for {tier}"
+
+    def test_tier_limits_are_ascending(self):
+        """Pro limits should be >= Free, Enterprise >= Pro"""
+        free = TIER_LIMITS[UserTier.FREE]
+        pro = TIER_LIMITS[UserTier.PRO]
+        ent = TIER_LIMITS[UserTier.ENTERPRISE]
+
+        assert pro.max_repos >= free.max_repos
+        assert pro.max_files_per_repo >= free.max_files_per_repo
+        assert pro.max_functions_per_repo >= free.max_functions_per_repo
+        assert ent.max_files_per_repo >= pro.max_files_per_repo
+        assert ent.max_functions_per_repo >= pro.max_functions_per_repo
+
+
+class TestUserTierDetection:
+    """Verify tier detection from DB"""
+    def test_default_tier_is_free(self, limiter):
+        """Unknown users default to free tier"""
+        with patch.object(limiter, '_get_tier_from_db', return_value=UserTier.FREE):
+            tier = limiter.get_user_tier("nonexistent-user")
+        assert tier == UserTier.FREE
+
+    def test_recognizes_pro_tier(self, limiter):
+        with patch.object(limiter, '_get_tier_from_db', return_value=UserTier.PRO):
+            tier = limiter.get_user_tier("user-123")
+        assert tier == UserTier.PRO
+
+    def test_recognizes_enterprise_tier(self, limiter):
+        with patch.object(limiter, '_get_tier_from_db', return_value=UserTier.ENTERPRISE):
+            tier = limiter.get_user_tier("user-456")
+        assert tier == UserTier.ENTERPRISE
+
+
+class TestRepoCountLimits:
+    def test_free_user_can_add_first_repo(self, limiter):
+        with patch.object(limiter, 'get_user_tier', return_value=UserTier.FREE), \
+             patch.object(limiter, 'get_user_repo_count', return_value=0):
+            result = limiter.check_repo_count("user-free")
+            assert result.allowed is True
+
+    def test_free_user_blocked_at_limit(self, limiter):
+        with patch.object(limiter, 'get_user_tier') as mock_tier:
+            mock_tier.return_value = UserTier.FREE
+            with patch.object(limiter, 'get_user_repo_count', return_value=1):
+                result = limiter.check_repo_count("user-free")
+                assert result.allowed is False
+
+    def test_pro_user_can_add_up_to_5(self, limiter):
+        with patch.object(limiter, 'get_user_tier') as mock_tier:
+            mock_tier.return_value = UserTier.PRO
+            with patch.object(limiter, 'get_user_repo_count', return_value=4):
+                result = limiter.check_repo_count("user-pro")
+                assert result.allowed is True
+
+    def test_pro_user_blocked_at_5(self, limiter):
+        with patch.object(limiter, 'get_user_tier') as mock_tier:
+            mock_tier.return_value = UserTier.PRO
+            with patch.object(limiter, 'get_user_repo_count', return_value=5):
+                result = limiter.check_repo_count("user-pro")
+                assert result.allowed is False
+
+    def test_enterprise_user_can_add_up_to_10(self, limiter):
+        with patch.object(limiter, 'get_user_tier') as mock_tier:
+            mock_tier.return_value = UserTier.ENTERPRISE
+            with patch.object(limiter, 'get_user_repo_count', return_value=9):
+                result = limiter.check_repo_count("user-ent")
+                assert result.allowed is True
+
+    def test_enterprise_user_blocked_at_10(self, limiter):
+        with patch.object(limiter, 'get_user_tier') as mock_tier:
+            mock_tier.return_value = UserTier.ENTERPRISE
+            with patch.object(limiter, 'get_user_repo_count', return_value=10):
+                result = limiter.check_repo_count("user-ent")
+                assert result.allowed is False
+
+
+class TestUsageSummary:
+    def test_returns_tier_info(self, limiter):
+        with patch.object(limiter, 'get_user_tier') as mock_tier, \
+             patch.object(limiter, 'get_limits') as mock_limits, \
+             patch.object(limiter, 'get_user_repo_count', return_value=2):
+            mock_tier.return_value = UserTier.PRO
+            mock_limits.return_value = TIER_LIMITS[UserTier.PRO]
+
+            summary = limiter.get_usage_summary("user-pro")
+            assert summary["tier"] == "pro"
+            assert summary["repositories"]["current"] == 2
+            assert summary["repositories"]["limit"] == 5
+            assert summary["limits"]["max_functions_per_repo"] == 100000
+            assert summary["features"]["priority_indexing"] is True
+
+    def test_invalid_user_returns_free_defaults(self, limiter):
+        summary = limiter.get_usage_summary("")
+        assert summary["tier"] == "free"
+        assert summary["repositories"]["current"] == 0