@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/tests/typescript_outline_format_tests.rs

@@ -0,0 +1,2188 @@
+use anyhow::Result;
+use std::fs;
+use tempfile::TempDir;
+
+mod common;
+use common::TestContext;
+
+#[test]
+fn test_typescript_outline_basic_symbols() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("basic.ts");
+
+    let content = r#"// TypeScript classes, interfaces, and types for testing
+
+import { Observable } from 'rxjs';
+
+/**
+ * Interface for calculator operations.
+ */
+interface CalculatorOperations {
+    add(x: number, y: number): number;
+    subtract(x: number, y: number): number;
+    multiply(x: number, y: number): number;
+    divide(x: number, y: number): number;
+}
+
+/**
+ * Type alias for calculation result.
+ */
+type CalculationResult = {
+    value: number;
+    operation: string;
+    timestamp: Date;
+};
+
+/**
+ * Generic type for API responses.
+ */
+type ApiResponse<T> = {
+    data: T;
+    success: boolean;
+    message?: string;
+};
+
+/**
+ * Enum for calculation operations.
+ */
+enum OperationType {
+    ADDITION = 'ADD',
+    SUBTRACTION = 'SUB',
+    MULTIPLICATION = 'MUL',
+    DIVISION = 'DIV',
+}
+
+/**
+ * Abstract base class for calculators.
+ */
+abstract class BaseCalculator {
+    protected history: CalculationResult[] = [];
+
+    abstract calculate(operation: OperationType, x: number, y: number): number;
+
+    getHistory(): readonly CalculationResult[] {
+        return this.history;
+    }
+
+    protected recordOperation(operation: OperationType, result: number): void {
+        this.history.push({
+            value: result,
+            operation: operation.toString(),
+            timestamp: new Date(),
+        });
+    }
+}
+
+/**
+ * Advanced calculator implementation.
+ */
+class AdvancedCalculator extends BaseCalculator implements CalculatorOperations {
+    private precision: number;
+
+    constructor(precision: number = 2) {
+        super();
+        this.precision = precision;
+    }
+
+    add(x: number, y: number): number {
+        const result = this.roundToPrecision(x + y);
+        this.recordOperation(OperationType.ADDITION, result);
+        return result;
+    }
+
+    subtract(x: number, y: number): number {
+        const result = this.roundToPrecision(x - y);
+        this.recordOperation(OperationType.SUBTRACTION, result);
+        return result;
+    }
+
+    multiply(x: number, y: number): number {
+        const result = this.roundToPrecision(x * y);
+        this.recordOperation(OperationType.MULTIPLICATION, result);
+        return result;
+    }
+
+    divide(x: number, y: number): number {
+        if (y === 0) {
+            throw new Error('Division by zero is not allowed');
+        }
+        const result = this.roundToPrecision(x / y);
+        this.recordOperation(OperationType.DIVISION, result);
+        return result;
+    }
+
+    calculate(operation: OperationType, x: number, y: number): number {
+        switch (operation) {
+            case OperationType.ADDITION:
+                return this.add(x, y);
+            case OperationType.SUBTRACTION:
+                return this.subtract(x, y);
+            case OperationType.MULTIPLICATION:
+                return this.multiply(x, y);
+            case OperationType.DIVISION:
+                return this.divide(x, y);
+            default:
+                throw new Error(`Unsupported operation: ${operation}`);
+        }
+    }
+
+    private roundToPrecision(value: number): number {
+        return Math.round(value * Math.pow(10, this.precision)) / Math.pow(10, this.precision);
+    }
+}
+
+/**
+ * Factory function for creating calculators.
+ */
+function createCalculator<T extends BaseCalculator>(
+    CalculatorClass: new (...args: any[]) => T,
+    ...args: any[]
+): T {
+    return new CalculatorClass(...args);
+}
+
+/**
+ * Async function for fetching calculator settings.
+ */
+async function fetchCalculatorSettings(): Promise<ApiResponse<{ precision: number }>> {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({
+                data: { precision: 4 },
+                success: true,
+                message: 'Settings loaded successfully',
+            });
+        }, 100);
+    });
+}
+
+/**
+ * Generic utility function with constraints.
+ */
+function processResults<T extends { value: number }>(results: T[]): T[] {
+    return results.filter(result => result.value !== 0);
+}
+
+// Export all types and classes
+export {
+    CalculatorOperations,
+    CalculationResult,
+    ApiResponse,
+    OperationType,
+    BaseCalculator,
+    AdvancedCalculator,
+    createCalculator,
+    fetchCalculatorSettings,
+    processResults,
+};
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "Calculator", // Search for Calculator-related symbols
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    let output2 = ctx.run_probe(&[
+        "search",
+        "interface", // Search for interface declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify TypeScript symbols are extracted in outline format
+    assert!(
+        output.contains("Calculator") || output2.contains("CalculatorOperations"),
+        "Missing Calculator-related symbols - output: {} | output2: {}",
+        output,
+        output2
+    );
+
+    // Test interface search
+    assert!(
+        output2.contains("interface"),
+        "Missing interface declarations - output2: {}",
+        output2
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_generic_types() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("generics.ts");
+
+    let content = r#"// Advanced TypeScript generics and conditional types
+
+/**
+ * Generic repository interface with CRUD operations.
+ */
+interface Repository<T, K = string> {
+    create(entity: Omit<T, 'id'>): Promise<T>;
+    findById(id: K): Promise<T | null>;
+    findAll(filter?: Partial<T>): Promise<T[]>;
+    update(id: K, updates: Partial<T>): Promise<T>;
+    delete(id: K): Promise<boolean>;
+}
+
+/**
+ * Conditional types for API responses.
+ */
+type ApiResult<T, E = Error> = T extends string
+    ? { message: T; success: true }
+    : T extends Error
+    ? { error: T; success: false }
+    : { data: T; success: boolean; error?: E };
+
+/**
+ * Mapped types for form validation.
+ */
+type ValidationRules<T> = {
+    [K in keyof T]: {
+        required?: boolean;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: RegExp;
+        custom?: (value: T[K]) => string | null;
+    };
+};
+
+/**
+ * Utility types for object manipulation.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+type DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
+};
+
+/**
+ * Generic service class with dependency injection.
+ */
+abstract class BaseService<TEntity, TRepository extends Repository<TEntity>> {
+    protected repository: TRepository;
+
+    constructor(repository: TRepository) {
+        this.repository = repository;
+    }
+
+    async create(entityData: Omit<TEntity, 'id'>): Promise<ApiResult<TEntity>> {
+        try {
+            const entity = await this.repository.create(entityData);
+            return { data: entity, success: true };
+        } catch (error) {
+            return { data: {} as TEntity, success: false, error: error as Error };
+        }
+    }
+
+    abstract validate(entity: Partial<TEntity>): ValidationResult<TEntity>;
+}
+
+/**
+ * Validation result type.
+ */
+interface ValidationResult<T> {
+    isValid: boolean;
+    errors: Partial<Record<keyof T, string>>;
+}
+
+/**
+ * Generic validator class.
+ */
+class Validator<T extends Record<string, any>> {
+    private rules: ValidationRules<T>;
+
+    constructor(rules: ValidationRules<T>) {
+        this.rules = rules;
+    }
+
+    validate(data: Partial<T>): ValidationResult<T> {
+        const errors: Partial<Record<keyof T, string>> = {};
+
+        for (const [key, rule] of Object.entries(this.rules) as [keyof T, any][]) {
+            const value = data[key];
+
+            if (rule.required && (value === undefined || value === null || value === '')) {
+                errors[key] = `${String(key)} is required`;
+                continue;
+            }
+
+            if (value && typeof value === 'string') {
+                if (rule.minLength && value.length < rule.minLength) {
+                    errors[key] = `${String(key)} must be at least ${rule.minLength} characters`;
+                }
+
+                if (rule.maxLength && value.length > rule.maxLength) {
+                    errors[key] = `${String(key)} must not exceed ${rule.maxLength} characters`;
+                }
+
+                if (rule.pattern && !rule.pattern.test(value)) {
+                    errors[key] = `${String(key)} format is invalid`;
+                }
+            }
+
+            if (rule.custom && value !== undefined) {
+                const customError = rule.custom(value);
+                if (customError) {
+                    errors[key] = customError;
+                }
+            }
+        }
+
+        return {
+            isValid: Object.keys(errors).length === 0,
+            errors,
+        };
+    }
+}
+
+/**
+ * User entity type for demonstration.
+ */
+interface User {
+    id: string;
+    username: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    age: number;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+/**
+ * User service implementation.
+ */
+class UserService extends BaseService<User, Repository<User>> {
+    private validator: Validator<User>;
+
+    constructor(repository: Repository<User>) {
+        super(repository);
+        this.validator = new Validator<User>({
+            username: {
+                required: true,
+                minLength: 3,
+                maxLength: 20,
+                pattern: /^[a-zA-Z0-9_]+$/,
+            },
+            email: {
+                required: true,
+                pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+            },
+            firstName: { required: true, minLength: 1 },
+            lastName: { required: true, minLength: 1 },
+            age: {
+                custom: (age: number) => {
+                    if (age < 0 || age > 150) {
+                        return 'Age must be between 0 and 150';
+                    }
+                    return null;
+                },
+            },
+        });
+    }
+
+    validate(entity: Partial<User>): ValidationResult<User> {
+        return this.validator.validate(entity);
+    }
+
+    async createUser(userData: Omit<User, 'id' | 'createdAt' | 'updatedAt'>): Promise<ApiResult<User>> {
+        const validation = this.validate(userData);
+
+        if (!validation.isValid) {
+            return {
+                data: {} as User,
+                success: false,
+                error: new Error(`Validation failed: ${JSON.stringify(validation.errors)}`),
+            };
+        }
+
+        const userWithTimestamps = {
+            ...userData,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        return this.create(userWithTimestamps);
+    }
+}
+
+/**
+ * Generic factory function with complex constraints.
+ */
+function createService<
+    TEntity extends { id: string },
+    TRepo extends Repository<TEntity>
+>(
+    ServiceClass: new (repo: TRepo) => BaseService<TEntity, TRepo>,
+    repository: TRepo
+): BaseService<TEntity, TRepo> {
+    return new ServiceClass(repository);
+}
+
+export {
+    Repository,
+    ApiResult,
+    ValidationRules,
+    DeepPartial,
+    DeepRequired,
+    BaseService,
+    ValidationResult,
+    Validator,
+    User,
+    UserService,
+    createService,
+};
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "Repository", // Search for Repository-related symbols
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    let output2 = ctx.run_probe(&[
+        "search",
+        "type", // Search for type declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify complex TypeScript features
+    assert!(
+        output.contains("Repository") || output2.contains("Repository"),
+        "Missing Repository-related symbols - output: {} | output2: {}",
+        output,
+        output2
+    );
+
+    // Test type search
+    assert!(
+        output2.contains("type"),
+        "Missing type declarations - output2: {}",
+        output2
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_react_components() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("react_components.tsx");
+
+    let content = r#"import React, { useState, useEffect, useCallback, useMemo, ReactNode } from 'react';
+
+// TypeScript interfaces for props
+interface BaseProps {
+    className?: string;
+    children?: ReactNode;
+}
+
+interface UserData {
+    id: string;
+    name: string;
+    email: string;
+    avatar?: string;
+}
+
+interface UserCardProps extends BaseProps {
+    user: UserData;
+    onEdit?: (user: UserData) => void;
+    onDelete?: (userId: string) => void;
+}
+
+interface UserListProps extends BaseProps {
+    users: UserData[];
+    loading?: boolean;
+    onUserAction?: (action: 'edit' | 'delete', user: UserData) => void;
+}
+
+// Custom hook with TypeScript
+function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void] {
+    const [storedValue, setStoredValue] = useState<T>(() => {
+        try {
+            const item = window.localStorage.getItem(key);
+            return item ? JSON.parse(item) : initialValue;
+        } catch (error) {
+            console.error(`Error reading localStorage key "${key}":`, error);
+            return initialValue;
+        }
+    });
+
+    const setValue = useCallback((value: T) => {
+        try {
+            setStoredValue(value);
+            window.localStorage.setItem(key, JSON.stringify(value));
+        } catch (error) {
+            console.error(`Error setting localStorage key "${key}":`, error);
+        }
+    }, [key]);
+
+    return [storedValue, setValue];
+}
+
+// Generic component with constraints
+interface ListProps<T> extends BaseProps {
+    items: T[];
+    renderItem: (item: T, index: number) => ReactNode;
+    keyExtractor: (item: T) => string;
+    emptyMessage?: string;
+}
+
+function List<T>({
+    items,
+    renderItem,
+    keyExtractor,
+    emptyMessage = "No items to display",
+    className,
+    children
+}: ListProps<T>): JSX.Element {
+    if (items.length === 0) {
+        return (
+            <div className={`empty-list ${className || ''}`}>
+                {emptyMessage}
+                {children}
+            </div>
+        );
+    }
+
+    return (
+        <div className={`list ${className || ''}`}>
+            {items.map((item, index) => (
+                <div key={keyExtractor(item)} className="list-item">
+                    {renderItem(item, index)}
+                </div>
+            ))}
+            {children}
+        </div>
+    );
+}
+
+// Functional component with complex state management
+const UserCard: React.FC<UserCardProps> = ({
+    user,
+    onEdit,
+    onDelete,
+    className,
+    children
+}) => {
+    const [isHovered, setIsHovered] = useState(false);
+    const [isExpanded, setIsExpanded] = useState(false);
+
+    const handleEdit = useCallback(() => {
+        onEdit?.(user);
+    }, [user, onEdit]);
+
+    const handleDelete = useCallback(() => {
+        if (window.confirm(`Are you sure you want to delete ${user.name}?`)) {
+            onDelete?.(user.id);
+        }
+    }, [user, onDelete]);
+
+    const displayName = useMemo(() => {
+        return user.name.length > 20
+            ? `${user.name.substring(0, 20)}...`
+            : user.name;
+    }, [user.name]);
+
+    return (
+        <div
+            className={`user-card ${className || ''} ${isHovered ? 'hovered' : ''}`}
+            onMouseEnter={() => setIsHovered(true)}
+            onMouseLeave={() => setIsHovered(false)}
+        >
+            <div className="user-header">
+                {user.avatar && (
+                    <img
+                        src={user.avatar}
+                        alt={`${user.name}'s avatar`}
+                        className="user-avatar"
+                    />
+                )}
+                <div className="user-info">
+                    <h3 className="user-name" title={user.name}>
+                        {displayName}
+                    </h3>
+                    <p className="user-email">{user.email}</p>
+                </div>
+            </div>
+
+            {isExpanded && (
+                <div className="user-details">
+                    <p>ID: {user.id}</p>
+                    {children}
+                </div>
+            )}
+
+            <div className="user-actions">
+                <button
+                    onClick={() => setIsExpanded(!isExpanded)}
+                    className="expand-button"
+                >
+                    {isExpanded ? 'Collapse' : 'Expand'}
+                </button>
+
+                {onEdit && (
+                    <button onClick={handleEdit} className="edit-button">
+                        Edit
+                    </button>
+                )}
+
+                {onDelete && (
+                    <button onClick={handleDelete} className="delete-button">
+                        Delete
+                    </button>
+                )}
+            </div>
+        </div>
+    );
+};
+
+// Component with complex effects and error handling
+const UserList: React.FC<UserListProps> = ({
+    users,
+    loading = false,
+    onUserAction,
+    className,
+    children
+}) => {
+    const [filteredUsers, setFilteredUsers] = useState<UserData[]>([]);
+    const [searchTerm, setSearchTerm] = useLocalStorage<string>('userSearch', '');
+    const [error, setError] = useState<string | null>(null);
+
+    // Effect for filtering users
+    useEffect(() => {
+        try {
+            if (!searchTerm.trim()) {
+                setFilteredUsers(users);
+            } else {
+                const filtered = users.filter(user =>
+                    user.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
+                    user.email.toLowerCase().includes(searchTerm.toLowerCase())
+                );
+                setFilteredUsers(filtered);
+            }
+            setError(null);
+        } catch (err) {
+            setError('Failed to filter users');
+            console.error('Filter error:', err);
+        }
+    }, [users, searchTerm]);
+
+    const handleUserAction = useCallback((action: 'edit' | 'delete', user: UserData) => {
+        try {
+            onUserAction?.(action, user);
+        } catch (err) {
+            setError(`Failed to ${action} user`);
+            console.error(`${action} error:`, err);
+        }
+    }, [onUserAction]);
+
+    if (loading) {
+        return (
+            <div className={`user-list loading ${className || ''}`}>
+                <div className="loading-spinner">Loading users...</div>
+                {children}
+            </div>
+        );
+    }
+
+    if (error) {
+        return (
+            <div className={`user-list error ${className || ''}`}>
+                <div className="error-message">Error: {error}</div>
+                <button onClick={() => setError(null)}>Dismiss</button>
+                {children}
+            </div>
+        );
+    }
+
+    return (
+        <div className={`user-list ${className || ''}`}>
+            <div className="search-container">
+                <input
+                    type="text"
+                    value={searchTerm}
+                    onChange={(e) => setSearchTerm(e.target.value)}
+                    placeholder="Search users..."
+                    className="search-input"
+                />
+            </div>
+
+            <List
+                items={filteredUsers}
+                keyExtractor={(user) => user.id}
+                renderItem={(user) => (
+                    <UserCard
+                        user={user}
+                        onEdit={(user) => handleUserAction('edit', user)}
+                        onDelete={(userId) => {
+                            const user = filteredUsers.find(u => u.id === userId);
+                            if (user) handleUserAction('delete', user);
+                        }}
+                    />
+                )}
+                emptyMessage="No users found"
+            />
+
+            {children}
+        </div>
+    );
+};
+
+// Higher-order component with TypeScript
+function withErrorBoundary<P extends object>(
+    WrappedComponent: React.ComponentType<P>
+): React.FC<P> {
+    return function WithErrorBoundaryComponent(props: P) {
+        const [hasError, setHasError] = useState(false);
+        const [error, setError] = useState<Error | null>(null);
+
+        useEffect(() => {
+            const handleError = (error: ErrorEvent) => {
+                setHasError(true);
+                setError(new Error(error.message));
+            };
+
+            window.addEventListener('error', handleError);
+            return () => window.removeEventListener('error', handleError);
+        }, []);
+
+        if (hasError) {
+            return (
+                <div className="error-boundary">
+                    <h2>Something went wrong</h2>
+                    <p>{error?.message}</p>
+                    <button onClick={() => {
+                        setHasError(false);
+                        setError(null);
+                    }}>
+                        Try again
+                    </button>
+                </div>
+            );
+        }
+
+        return <WrappedComponent {...props} />;
+    };
+}
+
+export {
+    UserData,
+    UserCardProps,
+    UserListProps,
+    useLocalStorage,
+    List,
+    UserCard,
+    UserList,
+    withErrorBoundary,
+};
+
+export default UserList;
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "React", // Search for React-related symbols
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    let output2 = ctx.run_probe(&[
+        "search",
+        "function", // Search for function declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify React component structures with TypeScript
+    // For now, just verify we get some results - React content might not be strongly matched
+    assert!(
+        !output.is_empty() || !output2.is_empty(),
+        "Should find some content in React components - output: {} | output2: {}",
+        output,
+        output2
+    );
+
+    // Test function search
+    assert!(
+        output2.contains("function"),
+        "Missing function declarations - output2: {}",
+        output2
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_test_patterns() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("test_patterns.ts");
+
+    let content = r#"// TypeScript test patterns with Jest and type safety
+
+import { Calculator } from './calculator';
+
+// Test types and interfaces
+interface TestUser {
+    id: string;
+    name: string;
+    email: string;
+}
+
+type MockedFunction<T extends (...args: any[]) => any> = jest.MockedFunction<T>;
+
+describe('Calculator', () => {
+    let calculator: Calculator;
+
+    beforeEach(() => {
+        calculator = new Calculator('Test Calculator');
+    });
+
+    afterEach(() => {
+        calculator = null as any;
+    });
+
+    describe('type safety', () => {
+        test('should handle number types correctly', () => {
+            const result: number = calculator.add(2, 3);
+            expect(result).toBe(5);
+            expect(typeof result).toBe('number');
+        });
+
+        test('should enforce parameter types', () => {
+            // TypeScript would catch these errors at compile time
+            expect(() => {
+                // @ts-ignore - Testing runtime behavior
+                calculator.add('2' as any, '3' as any);
+            }).toThrow('Invalid input type');
+        });
+    });
+
+    describe('generic methods', () => {
+        test('should work with generic operations', () => {
+            const operations = calculator.getOperations<'add' | 'subtract'>();
+            expect(operations).toContain('add');
+            expect(operations).toContain('subtract');
+        });
+    });
+});
+
+// Mock with proper TypeScript types
+const mockFetchUser = jest.fn() as MockedFunction<
+    (id: string) => Promise<TestUser>
+>;
+
+describe('async operations with types', () => {
+    beforeEach(() => {
+        mockFetchUser.mockClear();
+    });
+
+    test('should fetch user data with proper types', async () => {
+        const mockUser: TestUser = {
+            id: '123',
+            name: 'John Doe',
+            email: 'john@example.com',
+        };
+
+        mockFetchUser.mockResolvedValue(mockUser);
+
+        const result = await mockFetchUser('123');
+
+        expect(result).toEqual(mockUser);
+        expect(result.id).toBe('123');
+        expect(typeof result.name).toBe('string');
+
+        // TypeScript ensures these properties exist
+        expect(result.id).toBeDefined();
+        expect(result.name).toBeDefined();
+        expect(result.email).toBeDefined();
+    });
+
+    test('should handle async errors with proper types', async () => {
+        const mockError = new Error('Network error');
+        mockFetchUser.mockRejectedValue(mockError);
+
+        await expect(mockFetchUser('123')).rejects.toThrow('Network error');
+        await expect(mockFetchUser('123')).rejects.toBeInstanceOf(Error);
+    });
+});
+
+// Generic test helper functions
+function createMockUser(overrides: Partial<TestUser> = {}): TestUser {
+    return {
+        id: '123',
+        name: 'Test User',
+        email: 'test@example.com',
+        ...overrides,
+    };
+}
+
+function expectTypeOf<T>(value: T): jest.Matchers<T> {
+    return expect(value);
+}
+
+// Test class with TypeScript features
+class TestHelpers {
+    static createCalculator(precision: number = 2): Calculator {
+        return new Calculator('Test', precision);
+    }
+
+    static async waitFor<T>(
+        condition: () => T | Promise<T>,
+        timeout: number = 5000
+    ): Promise<T> {
+        const startTime = Date.now();
+
+        while (Date.now() - startTime < timeout) {
+            try {
+                const result = await condition();
+                if (result) {
+                    return result;
+                }
+            } catch (error) {
+                // Continue waiting
+            }
+
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+
+        throw new Error(`Condition not met within ${timeout}ms`);
+    }
+
+    static createPartialMock<T>(partial: Partial<T>): T {
+        return partial as T;
+    }
+}
+
+// Parameterized tests with types
+interface CalculationTestCase {
+    a: number;
+    b: number;
+    expected: number;
+    operation: 'add' | 'subtract' | 'multiply' | 'divide';
+}
+
+const calculationTestCases: CalculationTestCase[] = [
+    { a: 2, b: 3, expected: 5, operation: 'add' },
+    { a: 5, b: 2, expected: 3, operation: 'subtract' },
+    { a: 3, b: 4, expected: 12, operation: 'multiply' },
+    { a: 8, b: 2, expected: 4, operation: 'divide' },
+];
+
+describe.each(calculationTestCases)(
+    'calculator operations',
+    ({ a, b, expected, operation }) => {
+        test(`${operation}(${a}, ${b}) should equal ${expected}`, () => {
+            const calculator = TestHelpers.createCalculator();
+            const result = calculator[operation](a, b);
+            expect(result).toBe(expected);
+        });
+    }
+);
+
+// Mock classes with TypeScript
+class MockUserService {
+    private users: Map<string, TestUser> = new Map();
+
+    async getUser(id: string): Promise<TestUser | null> {
+        return this.users.get(id) || null;
+    }
+
+    async createUser(userData: Omit<TestUser, 'id'>): Promise<TestUser> {
+        const user: TestUser = {
+            ...userData,
+            id: Math.random().toString(36).substr(2, 9),
+        };
+
+        this.users.set(user.id, user);
+        return user;
+    }
+
+    async updateUser(id: string, updates: Partial<TestUser>): Promise<TestUser> {
+        const existing = this.users.get(id);
+        if (!existing) {
+            throw new Error('User not found');
+        }
+
+        const updated = { ...existing, ...updates };
+        this.users.set(id, updated);
+        return updated;
+    }
+
+    clear(): void {
+        this.users.clear();
+    }
+}
+
+describe('UserService integration tests', () => {
+    let userService: MockUserService;
+
+    beforeEach(() => {
+        userService = new MockUserService();
+    });
+
+    afterEach(() => {
+        userService.clear();
+    });
+
+    test('should create and retrieve users', async () => {
+        const userData = { name: 'Alice', email: 'alice@example.com' };
+        const createdUser = await userService.createUser(userData);
+
+        expect(createdUser.id).toBeDefined();
+        expect(createdUser.name).toBe(userData.name);
+        expect(createdUser.email).toBe(userData.email);
+
+        const retrievedUser = await userService.getUser(createdUser.id);
+        expect(retrievedUser).toEqual(createdUser);
+    });
+
+    test('should update user data', async () => {
+        const user = await userService.createUser({
+            name: 'Bob',
+            email: 'bob@example.com',
+        });
+
+        const updates = { name: 'Robert' };
+        const updatedUser = await userService.updateUser(user.id, updates);
+
+        expect(updatedUser.name).toBe('Robert');
+        expect(updatedUser.email).toBe('bob@example.com');
+        expect(updatedUser.id).toBe(user.id);
+    });
+});
+
+export {
+    TestUser,
+    MockedFunction,
+    createMockUser,
+    expectTypeOf,
+    TestHelpers,
+    CalculationTestCase,
+    MockUserService,
+};
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "test", // Search for test-related symbols
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    let output2 = ctx.run_probe(&[
+        "search",
+        "function", // Search for function declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify TypeScript test patterns - should find describe blocks or test functions
+    assert!(
+        output.contains("test") || output.contains("describe"),
+        "Should find test-related symbols - output: {}",
+        output
+    );
+
+    // Test function search
+    assert!(
+        output2.contains("function"),
+        "Missing function declarations - output2: {}",
+        output2
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_large_function_closing_braces() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("large_function.ts");
+
+    let content = r#"/**
+ * Large TypeScript function with complex types and nested blocks.
+ */
+function complexDataProcessor<T extends { value: number; category?: string }>(
+    data: T[],
+    options: {
+        threshold: number;
+        categorizer?: (item: T) => string;
+        validator?: (item: T) => boolean;
+    }
+): { processed: T[]; summary: Record<string, number> } {
+    const results: T[] = [];
+    const categories = new Map<string, T[]>();
+    const summary: Record<string, number> = {};
+
+    // Phase 1: Validation and categorization
+    for (const [index, item] of data.entries()) {
+        // Validation phase
+        if (options.validator) {
+            if (!options.validator(item)) {
+                console.warn(`Item at index ${index} failed validation:`, item);
+                continue;
+            }
+        }
+
+        // Default validation
+        if (typeof item.value !== 'number' || isNaN(item.value)) {
+            console.warn(`Item at index ${index} has invalid value:`, item);
+            continue;
+        }
+
+        // Categorization
+        let category: string;
+        if (options.categorizer) {
+            category = options.categorizer(item);
+        } else {
+            if (item.value < 0) {
+                category = 'negative';
+            } else if (item.value === 0) {
+                category = 'zero';
+            } else if (item.value < options.threshold) {
+                category = 'below_threshold';
+            } else {
+                category = 'above_threshold';
+            }
+        }
+
+        // Store in category map
+        if (!categories.has(category)) {
+            categories.set(category, []);
+        }
+        categories.get(category)!.push(item);
+    }
+
+    // Phase 2: Processing each category
+    for (const [categoryName, items] of categories) {
+        summary[categoryName] = items.length;
+
+        switch (categoryName) {
+            case 'negative':
+                for (const item of items) {
+                    const processedItem: T = {
+                        ...item,
+                        value: Math.abs(item.value),
+                        category: 'processed_negative',
+                    } as T;
+                    results.push(processedItem);
+                }
+                break;
+
+            case 'zero':
+                for (const item of items) {
+                    const processedItem: T = {
+                        ...item,
+                        value: 0.1, // Convert zero to small positive
+                        category: 'processed_zero',
+                    } as T;
+                    results.push(processedItem);
+                }
+                break;
+
+            case 'below_threshold':
+                for (const item of items) {
+                    const multiplier = options.threshold / item.value;
+                    const processedItem: T = {
+                        ...item,
+                        value: item.value * multiplier,
+                        category: 'normalized',
+                    } as T;
+                    results.push(processedItem);
+                }
+                break;
+
+            case 'above_threshold':
+                for (const item of items) {
+                    const processedItem: T = {
+                        ...item,
+                        category: 'above_threshold',
+                    } as T;
+                    results.push(processedItem);
+                }
+                break;
+
+            default:
+                // Custom category processing
+                for (const item of items) {
+                    const processedItem: T = {
+                        ...item,
+                        category: `custom_${categoryName}`,
+                    } as T;
+                    results.push(processedItem);
+                }
+                break;
+        }
+    }
+
+    // Phase 3: Final sorting and validation
+    results.sort((a, b) => {
+        if (a.category !== b.category) {
+            return a.category!.localeCompare(b.category!);
+        }
+        return a.value - b.value;
+    });
+
+    // Final validation pass
+    const validatedResults: T[] = [];
+    for (const result of results) {
+        if (result.value > 0 && result.category) {
+            validatedResults.push(result);
+        }
+    }
+
+    return {
+        processed: validatedResults,
+        summary,
+    };
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "complexDataProcessor", // Search for the specific large function
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify large function is shown with closing braces
+    assert!(
+        output.contains("complexDataProcessor"),
+        "Missing complexDataProcessor function - output: {}",
+        output
+    );
+
+    // Should have closing braces for large blocks (if the function is found and formatted)
+    if output.contains("complexDataProcessor") {
+        let closing_braces_count = output.matches("}").count();
+        assert!(
+            closing_braces_count >= 1,
+            "Should have closing braces for nested blocks - output: {}",
+            output
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_search_command() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("search_test.ts");
+
+    let content = r#"interface DataProcessor {
+    processData<T>(data: T[]): T[];
+    getProcessedCount(): number;
+}
+
+class AdvancedDataProcessor implements DataProcessor {
+    private processedCount: number = 0;
+
+    processData<T>(data: T[]): T[] {
+        this.processedCount++;
+        return data.filter(item => item !== null && item !== undefined);
+    }
+
+    getProcessedCount(): number {
+        return this.processedCount;
+    }
+}
+
+function processFile(filename: string): Promise<string> {
+    return Promise.resolve(`Processed ${filename}`);
+}
+
+async function processAsync<T>(data: T): Promise<{ processed: boolean } & T> {
+    return { processed: true, ...data };
+}
+
+function testDataProcessing(): void {
+    const processor: DataProcessor = new AdvancedDataProcessor();
+    const result = processor.processData([1, 2, null, 3]);
+    console.assert(result.length === 3);
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "process",
+        temp_dir.path().to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+    ])?;
+
+    // Should find symbols containing "process"
+    assert!(
+        output.contains("DataProcessor")
+            || output.contains("processData")
+            || output.contains("processFile")
+            || output.contains("processAsync"),
+        "Should find process-related symbols - output: {}",
+        output
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_small_function_no_closing_braces() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("small_functions.ts");
+
+    let content = r#"/**
+ * Small TypeScript functions that should NOT get closing braces.
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+
+type Vector = {
+    start: Point;
+    end: Point;
+};
+
+function add(a: number, b: number): number {
+    return a + b;
+}
+
+function multiply(x: number, y: number): number {
+    return x * y;
+}
+
+const subtract = (a: number, b: number): number => {
+    return a - b;
+};
+
+const divide: (x: number, y: number) => number = (x, y) => {
+    if (y === 0) throw new Error('Division by zero');
+    return x / y;
+};
+
+function getDistance(p1: Point, p2: Point): number {
+    const dx = p2.x - p1.x;
+    const dy = p2.y - p1.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+async function fetchData<T>(url: string): Promise<T> {
+    const response = await fetch(url);
+    return response.json();
+}
+
+class SmallClass {
+    private value: number;
+
+    constructor(value: number) {
+        this.value = value;
+    }
+
+    getValue(): number {
+        return this.value;
+    }
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "function", // Search for function declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify small functions are found but don't have excessive closing braces
+    assert!(
+        output.contains("function") || output.contains("add") || output.contains("multiply"),
+        "Should find small functions - output: {}",
+        output
+    );
+
+    // Small functions should have minimal closing braces (ideally none for outline)
+    let closing_braces_count = output.matches("} //").count(); // closing brace comments
+    assert!(
+        closing_braces_count <= 2, // Allow some, but not excessive
+        "Small functions should not have many closing brace comments - output: {}",
+        output
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_keyword_highlighting() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("keyword_highlighting.ts");
+
+    let content = r#"// TypeScript with various keywords for highlighting tests
+interface DatabaseConfig {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+}
+
+type ConnectionStatus = 'connected' | 'disconnected' | 'connecting' | 'error';
+
+enum LogLevel {
+    DEBUG = 'debug',
+    INFO = 'info',
+    WARN = 'warn',
+    ERROR = 'error',
+}
+
+abstract class BaseLogger {
+    protected level: LogLevel;
+
+    constructor(level: LogLevel = LogLevel.INFO) {
+        this.level = level;
+    }
+
+    abstract log(message: string, level: LogLevel): void;
+}
+
+class ConsoleLogger extends BaseLogger {
+    log(message: string, level: LogLevel): void {
+        if (this.shouldLog(level)) {
+            console.log(`[${level}] ${message}`);
+        }
+    }
+
+    private shouldLog(level: LogLevel): boolean {
+        const levels = Object.values(LogLevel);
+        return levels.indexOf(level) >= levels.indexOf(this.level);
+    }
+}
+
+function createLogger(config: DatabaseConfig): BaseLogger {
+    return new ConsoleLogger();
+}
+
+async function connectDatabase(config: DatabaseConfig): Promise<ConnectionStatus> {
+    try {
+        // Simulate connection logic
+        await new Promise(resolve => setTimeout(resolve, 100));
+        return 'connected';
+    } catch (error) {
+        return 'error';
+    }
+}
+
+// Generic function with constraints
+function processData<T extends { id: string }>(data: T[]): T[] {
+    return data.filter(item => item.id && item.id.length > 0);
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+
+    // Test various TypeScript keywords
+    for keyword in [
+        "interface",
+        "type",
+        "enum",
+        "abstract",
+        "extends",
+        "async",
+        "function",
+    ] {
+        let output = ctx.run_probe(&[
+            "search",
+            keyword,
+            test_file.to_str().unwrap(),
+            "--format",
+            "outline",
+            "--allow-tests",
+        ])?;
+
+        // Should find the keyword in outline format
+        assert!(
+            output.contains(keyword) || !output.is_empty(),
+            "Should find keyword '{}' - output: {}",
+            keyword,
+            output
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_array_object_truncation() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("array_object_truncation.ts");
+
+    let content = r#"// TypeScript with large arrays and objects for truncation testing
+interface UserProfile {
+    id: string;
+    name: string;
+    email: string;
+    preferences: {
+        theme: 'light' | 'dark';
+        language: string;
+        notifications: boolean;
+        keywords: string[];
+    };
+}
+
+const largeArray: string[] = [
+    'first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth',
+    'ninth', 'tenth', 'eleventh', 'twelfth', 'thirteenth', 'fourteenth', 'fifteenth',
+    'sixteenth', 'seventeenth', 'eighteenth', 'nineteenth', 'twentieth', 'keyword',
+    'twenty-first', 'twenty-second', 'twenty-third', 'twenty-fourth', 'twenty-fifth',
+];
+
+const complexObject: UserProfile = {
+    id: '12345',
+    name: 'John Doe',
+    email: 'john@example.com',
+    preferences: {
+        theme: 'dark',
+        language: 'en',
+        notifications: true,
+        keywords: ['typescript', 'javascript', 'react', 'node', 'keyword', 'development'],
+    },
+};
+
+type LargeTypeDefinition = {
+    field1: string;
+    field2: number;
+    field3: boolean;
+    field4: string[];
+    field5: {
+        nested1: string;
+        nested2: number;
+        nested3: boolean;
+        nested4: string;
+        nested5: number;
+        keyword: string;
+    };
+    field6: Date;
+    field7: RegExp;
+    field8: Function;
+    field9: any;
+    field10: unknown;
+};
+
+function processLargeData(data: LargeTypeDefinition[]): LargeTypeDefinition[] {
+    return data.filter(item =>
+        item.field1 &&
+        item.field2 > 0 &&
+        item.field3 !== null &&
+        item.field4.length > 0 &&
+        item.field5.keyword.includes('keyword')
+    );
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "keyword", // Search for keyword that should be preserved even in truncated arrays/objects
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Should find the keyword even in truncated content
+    assert!(
+        output.contains("keyword"),
+        "Should preserve keyword in truncated content - output: {}",
+        output
+    );
+
+    let output2 = ctx.run_probe(&[
+        "search",
+        "largeArray",
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Should contain array/object content, possibly with truncation
+    assert!(
+        output2.contains("largeArray") || output2.contains("string[]"),
+        "Should find large array definition - output2: {}",
+        output2
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_advanced_features() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("advanced_features.ts");
+
+    let content = r#"// Advanced TypeScript features: decorators, utility types, conditional types
+import { Component } from '@angular/core';
+
+// Decorators
+@Component({
+    selector: 'app-user',
+    template: '<div>{{user.name}}</div>'
+})
+class UserComponent {
+    @Input() user: User;
+
+    @Output() userSelected = new EventEmitter<User>();
+
+    @HostListener('click', ['$event'])
+    onClick(event: MouseEvent): void {
+        this.userSelected.emit(this.user);
+    }
+}
+
+// Utility types
+type PartialUser = Partial<User>;
+type RequiredUser = Required<User>;
+type PickedUser = Pick<User, 'id' | 'name'>;
+type OmittedUser = Omit<User, 'password'>;
+type RecordType = Record<string, number>;
+
+// Conditional types
+type NonNullable<T> = T extends null | undefined ? never : T;
+type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
+type Parameters<T> = T extends (...args: infer P) => any ? P : never;
+
+// Mapped types
+type Readonly<T> = {
+    readonly [P in keyof T]: T[P];
+};
+
+type Optional<T> = {
+    [P in keyof T]?: T[P];
+};
+
+// Template literal types
+type EventName<T extends string> = `on${Capitalize<T>}`;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+type ApiEndpoint<T extends HttpMethod> = `/${Lowercase<T>}/api`;
+
+// Advanced generic constraints
+interface Identifiable {
+    id: string;
+}
+
+interface Timestamped {
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+type Entity<T> = T & Identifiable & Timestamped;
+
+class Repository<T extends Identifiable> {
+    private items: Map<string, T> = new Map();
+
+    save(item: T): void {
+        this.items.set(item.id, item);
+    }
+
+    findById(id: string): T | undefined {
+        return this.items.get(id);
+    }
+
+    findAll(): T[] {
+        return Array.from(this.items.values());
+    }
+}
+
+// Function overloads
+function createElement(tagName: 'div'): HTMLDivElement;
+function createElement(tagName: 'span'): HTMLSpanElement;
+function createElement(tagName: 'input'): HTMLInputElement;
+function createElement(tagName: string): HTMLElement;
+function createElement(tagName: string): HTMLElement {
+    return document.createElement(tagName);
+}
+
+// Namespace and module augmentation
+namespace Utils {
+    export function formatDate(date: Date): string {
+        return date.toISOString().split('T')[0];
+    }
+
+    export namespace Math {
+        export function clamp(value: number, min: number, max: number): number {
+            return Math.min(Math.max(value, min), max);
+        }
+    }
+}
+
+// Module augmentation
+declare global {
+    interface Window {
+        customProperty: string;
+    }
+}
+
+declare module 'express' {
+    interface Request {
+        user?: User;
+    }
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+
+    // Test decorator patterns
+    let output1 = ctx.run_probe(&[
+        "search",
+        "Component",
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Test utility types
+    let output2 = ctx.run_probe(&[
+        "search",
+        "Partial",
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Test conditional types
+    let output3 = ctx.run_probe(&[
+        "search",
+        "extends",
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+    ])?;
+
+    // Should find advanced TypeScript features
+    assert!(
+        !output1.is_empty() || !output2.is_empty() || !output3.is_empty(),
+        "Should find advanced TypeScript features - output1: {} | output2: {} | output3: {}",
+        output1,
+        output2,
+        output3
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_outline_control_flow_statements() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("control_flow.ts");
+
+    let content = r#"/**
+ * TypeScript control flow structures for testing outline format.
+ */
+interface User {
+    id: string;
+    name: string;
+    age: number;
+    role: 'admin' | 'user' | 'guest';
+}
+
+function validateUser(user: User): boolean {
+    // Simple if statement
+    if (!user.id || user.id.length === 0) {
+        return false;
+    }
+
+    // Switch statement with TypeScript types
+    switch (user.role) {
+        case 'admin':
+            return user.age >= 21;
+        case 'user':
+            return user.age >= 13;
+        case 'guest':
+            return user.age >= 0;
+        default:
+            return false;
+    }
+}
+
+function processUsers(users: User[]): User[] {
+    const validUsers: User[] = [];
+
+    // For loop with TypeScript
+    for (let i = 0; i < users.length; i++) {
+        const user = users[i];
+
+        // Nested if-else
+        if (validateUser(user)) {
+            if (user.role === 'admin') {
+                // Complex nested logic
+                if (user.age > 30) {
+                    validUsers.push({ ...user, role: 'admin' });
+                } else {
+                    validUsers.push({ ...user, role: 'user' });
+                }
+            } else {
+                validUsers.push(user);
+            }
+        }
+    }
+
+    return validUsers;
+}
+
+async function fetchAndProcessUsers(): Promise<User[]> {
+    try {
+        const response = await fetch('/api/users');
+        const users: User[] = await response.json();
+
+        // While loop
+        let retries = 3;
+        while (retries > 0 && users.length === 0) {
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            retries--;
+        }
+
+        return processUsers(users);
+    } catch (error) {
+        console.error('Failed to fetch users:', error);
+        return [];
+    } finally {
+        console.log('User fetch operation completed');
+    }
+}
+
+class UserManager {
+    private users: Map<string, User> = new Map();
+
+    addUser(user: User): void {
+        // TypeScript type guards
+        if (this.isValidUser(user)) {
+            this.users.set(user.id, user);
+        } else {
+            throw new Error('Invalid user');
+        }
+    }
+
+    private isValidUser(user: any): user is User {
+        return (
+            typeof user === 'object' &&
+            typeof user.id === 'string' &&
+            typeof user.name === 'string' &&
+            typeof user.age === 'number' &&
+            ['admin', 'user', 'guest'].includes(user.role)
+        );
+    }
+
+    getUsersByRole(role: User['role']): User[] {
+        const result: User[] = [];
+
+        // For-of loop with Map
+        for (const [id, user] of this.users.entries()) {
+            if (user.role === role) {
+                result.push(user);
+            }
+        }
+
+        return result;
+    }
+}
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "function", // Search for function declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify control flow structures are shown with proper formatting
+    assert!(
+        output.contains("function")
+            || output.contains("validateUser")
+            || output.contains("processUsers"),
+        "Should find control flow functions - output: {}",
+        output
+    );
+
+    // Test class search
+    let output2 = ctx.run_probe(&[
+        "search",
+        "class", // Search for class declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    assert!(
+        output2.contains("class") || output2.contains("UserManager"),
+        "Should find class with control flow - output2: {}",
+        output2
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_typescript_tsx_file_support() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let test_file = temp_dir.path().join("react_component.tsx"); // Note: .tsx extension
+
+    let content = r#"import React, { useState, useEffect, FC, ReactElement } from 'react';
+
+interface Props {
+    title: string;
+    count?: number;
+    onIncrement?: () => void;
+}
+
+interface State {
+    value: number;
+    loading: boolean;
+}
+
+// Functional component with TypeScript
+const Counter: FC<Props> = ({ title, count = 0, onIncrement }): ReactElement => {
+    const [state, setState] = useState<State>({
+        value: count,
+        loading: false,
+    });
+
+    useEffect(() => {
+        setState(prev => ({ ...prev, value: count }));
+    }, [count]);
+
+    const handleIncrement = (): void => {
+        setState(prev => ({ ...prev, loading: true }));
+
+        setTimeout(() => {
+            setState(prev => ({
+                value: prev.value + 1,
+                loading: false,
+            }));
+            onIncrement?.();
+        }, 100);
+    };
+
+    return (
+        <div className="counter">
+            <h2>{title}</h2>
+            <div className="counter-display">
+                Count: {state.loading ? '...' : state.value}
+            </div>
+            <button
+                onClick={handleIncrement}
+                disabled={state.loading}
+                type="button"
+            >
+                {state.loading ? 'Loading...' : 'Increment'}
+            </button>
+        </div>
+    );
+};
+
+// Class component with TypeScript
+interface ClassCounterProps {
+    initialValue: number;
+    step?: number;
+}
+
+interface ClassCounterState {
+    count: number;
+    history: number[];
+}
+
+class ClassCounter extends React.Component<ClassCounterProps, ClassCounterState> {
+    constructor(props: ClassCounterProps) {
+        super(props);
+        this.state = {
+            count: props.initialValue,
+            history: [props.initialValue],
+        };
+    }
+
+    increment = (): void => {
+        const step = this.props.step || 1;
+        this.setState(prevState => ({
+            count: prevState.count + step,
+            history: [...prevState.history, prevState.count + step],
+        }));
+    };
+
+    reset = (): void => {
+        this.setState({
+            count: this.props.initialValue,
+            history: [this.props.initialValue],
+        });
+    };
+
+    render(): ReactElement {
+        const { count, history } = this.state;
+
+        return (
+            <div className="class-counter">
+                <div>Count: {count}</div>
+                <div>History: {history.join(', ')}</div>
+                <button onClick={this.increment}>Increment</button>
+                <button onClick={this.reset}>Reset</button>
+            </div>
+        );
+    }
+}
+
+// Higher-order component with TypeScript
+function withLoading<P extends object>(
+    WrappedComponent: React.ComponentType<P>
+): React.FC<P & { loading?: boolean }> {
+    return function WithLoadingComponent({ loading = false, ...props }) {
+        if (loading) {
+            return <div>Loading...</div>;
+        }
+        return <WrappedComponent {...props as P} />;
+    };
+}
+
+// Custom hook with TypeScript
+function useCounter(initialValue: number = 0): [number, () => void, () => void] {
+    const [count, setCount] = useState<number>(initialValue);
+
+    const increment = (): void => {
+        setCount(prev => prev + 1);
+    };
+
+    const reset = (): void => {
+        setCount(initialValue);
+    };
+
+    return [count, increment, reset];
+}
+
+export { Counter, ClassCounter, withLoading, useCounter };
+export type { Props, State, ClassCounterProps, ClassCounterState };
+"#;
+
+    fs::write(&test_file, content)?;
+
+    let ctx = TestContext::new();
+    let output = ctx.run_probe(&[
+        "search",
+        "React", // Search for React-related symbols
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    let output2 = ctx.run_probe(&[
+        "search",
+        "function", // Search for function declarations
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    // Verify TSX file support - should handle both TypeScript and JSX
+    assert!(
+        !output.is_empty() || !output2.is_empty(),
+        "Should process .tsx files correctly - output: {} | output2: {}",
+        output,
+        output2
+    );
+
+    // Test component search
+    let output3 = ctx.run_probe(&[
+        "search",
+        "Counter",
+        test_file.to_str().unwrap(),
+        "--format",
+        "outline",
+        "--allow-tests",
+        "--exact",
+    ])?;
+
+    assert!(
+        output3.contains("Counter") || !output3.is_empty(),
+        "Should find Counter component in TSX - output3: {}",
+        output3
+    );
+
+    Ok(())
+}