@defai.digital/automatosx 8.0.19 → 8.0.21

package/dist/lsp/__tests__/Day74LSPServer.test.js

@@ -1,713 +0,0 @@
-/**
- * Day 74: LSP Server Foundation Tests
- *
- * Comprehensive test suite for LSP server implementation.
- * Tests: LSP Server, Document Manager, Providers, Integration Service, Utilities
- *
- * Total: 50+ tests
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import Database from 'better-sqlite3';
-import { DocumentManager } from '../server/DocumentManager.js';
-import { IntegrationService } from '../server/IntegrationService.js';
-import { DefinitionProvider } from '../providers/DefinitionProvider.js';
-import { ReferencesProvider } from '../providers/ReferencesProvider.js';
-import { HoverProvider } from '../providers/HoverProvider.js';
-import { CompletionProvider } from '../providers/CompletionProvider.js';
-import { filePathToUri, uriToFilePath, offsetToPosition, positionToOffset, getWordAtPosition, rangeContainsPosition, rangesOverlap, comparePositions, mapSymbolKind, mapCompletionItemKind, } from '../utils/lsp-utils.js';
-import { runMigrations } from '../../database/migrations.js';
-import { closeDatabase, setDatabase } from '../../database/connection.js';
-// Mock ParserRegistry to avoid loading all 50+ language grammars in tests
-// This prevents "Invalid language object" errors from tree-sitter
-vi.mock('../../parser/ParserRegistry.js', async () => {
-    const { TypeScriptParserService } = await import('../../parser/TypeScriptParserService.js');
-    class MockParserRegistry {
-        parsers = new Map();
-        extensionMap = new Map();
-        constructor() {
-            // Only register TypeScript parser to avoid loading all 50+ language grammars
-            const tsParser = new TypeScriptParserService();
-            this.registerParser(tsParser);
-        }
-        registerParser(parser) {
-            this.parsers.set(parser.language, parser);
-            for (const ext of parser.extensions) {
-                this.extensionMap.set(ext, parser);
-            }
-        }
-        getParser(language) {
-            return this.parsers.get(language) || null;
-        }
-        getParserForFile(filePath) {
-            const ext = filePath.substring(filePath.lastIndexOf('.'));
-            return this.extensionMap.get(ext) || null;
-        }
-    }
-    // Create singleton instance
-    const mockRegistry = new MockParserRegistry();
-    return {
-        ParserRegistry: MockParserRegistry,
-        getParserRegistry: () => mockRegistry,
-    };
-});
-// Mock data
-const SAMPLE_TS_CODE = `
-function calculateSum(a: number, b: number): number {
-  return a + b;
-}
-
-class Calculator {
-  constructor(private value: number = 0) {}
-
-  add(n: number): void {
-    this.value += n;
-  }
-
-  getValue(): number {
-    return this.value;
-  }
-}
-
-const result = calculateSum(10, 20);
-const calc = new Calculator();
-calc.add(5);
-`.trim();
-const SAMPLE_PY_CODE = `
-def calculate_sum(a, b):
-    """Calculate the sum of two numbers."""
-    return a + b
-
-class Calculator:
-    def __init__(self, value=0):
-        self.value = value
-
-    def add(self, n):
-        self.value += n
-
-    def get_value(self):
-        return self.value
-
-result = calculate_sum(10, 20)
-calc = Calculator()
-calc.add(5)
-`.trim();
-const TEST_FILE_PATH = '/test/sample.ts';
-const TEST_FILE_URI = 'file:///test/sample.ts';
-// Global test database setup
-let testDb = null;
-/**
- * Setup test database with migrations
- * This runs before each test
- */
-function setupTestDatabase() {
-    // Close any existing global database connection
-    try {
-        closeDatabase();
-    }
-    catch (e) {
-        // Ignore if no connection exists
-    }
-    // Create fresh in-memory database for this test
-    testDb = new Database(':memory:');
-    runMigrations(testDb);
-    // Set it as the global database for this test
-    setDatabase(testDb);
-    return testDb;
-}
-/**
- * Teardown test database
- */
-function teardownTestDatabase() {
-    if (testDb) {
-        testDb.close();
-        testDb = null;
-    }
-    closeDatabase();
-}
-describe('Day 74: LSP Server Foundation', () => {
-    // Setup database once for all tests
-    beforeEach(() => {
-        setupTestDatabase();
-    });
-    afterEach(() => {
-        // Reset database for next test
-        teardownTestDatabase();
-    });
-    // ============================================================
-    // LSP Utilities Tests (5 tests)
-    // ============================================================
-    describe('LSP Utilities', () => {
-        it('should convert file path to URI', () => {
-            const uri = filePathToUri('/Users/test/file.ts');
-            expect(uri).toContain('file://');
-            expect(uri).toContain('/Users/test/file.ts');
-        });
-        it('should convert URI to file path', () => {
-            const filePath = uriToFilePath('file:///Users/test/file.ts');
-            expect(filePath).toBe('/Users/test/file.ts');
-        });
-        it('should convert offset to position', () => {
-            const content = 'line1\nline2\nline3';
-            const position = offsetToPosition(content, 11); // Start of 'line3'
-            expect(position).toEqual({ line: 2, character: 0 });
-        });
-        it('should convert position to offset', () => {
-            const content = 'line1\nline2\nline3';
-            const offset = positionToOffset(content, { line: 1, character: 0 });
-            expect(offset).toBe(6); // Start of 'line2'
-        });
-        it('should get word at position', () => {
-            const content = 'function calculateSum(a, b) {}';
-            const word = getWordAtPosition(content, { line: 0, character: 15 });
-            expect(word).toBe('calculateSum');
-        });
-    });
-    // ============================================================
-    // LSP Types Tests (5 tests)
-    // ============================================================
-    describe('LSP Types', () => {
-        it('should check if range contains position', () => {
-            const range = {
-                start: { line: 1, character: 5 },
-                end: { line: 3, character: 10 },
-            };
-            expect(rangeContainsPosition(range, { line: 2, character: 0 })).toBe(true);
-            expect(rangeContainsPosition(range, { line: 0, character: 0 })).toBe(false);
-            expect(rangeContainsPosition(range, { line: 4, character: 0 })).toBe(false);
-        });
-        it('should check if ranges overlap', () => {
-            const range1 = {
-                start: { line: 1, character: 0 },
-                end: { line: 3, character: 10 },
-            };
-            const range2 = {
-                start: { line: 2, character: 0 },
-                end: { line: 4, character: 10 },
-            };
-            expect(rangesOverlap(range1, range2)).toBe(true);
-        });
-        it('should compare positions correctly', () => {
-            expect(comparePositions({ line: 1, character: 5 }, { line: 1, character: 10 })).toBeLessThan(0);
-            expect(comparePositions({ line: 2, character: 0 }, { line: 1, character: 10 })).toBeGreaterThan(0);
-            expect(comparePositions({ line: 1, character: 5 }, { line: 1, character: 5 })).toBe(0);
-        });
-        it('should map symbol kind correctly', () => {
-            expect(mapSymbolKind('function')).toBe(12);
-            expect(mapSymbolKind('class')).toBe(5);
-            expect(mapSymbolKind('variable')).toBe(13);
-        });
-        it('should map completion item kind correctly', () => {
-            expect(mapCompletionItemKind('function')).toBe(3);
-            expect(mapCompletionItemKind('class')).toBe(7);
-            expect(mapCompletionItemKind('variable')).toBe(6);
-        });
-    });
-    // ============================================================
-    // Document Manager Tests (8 tests)
-    // ============================================================
-    describe('Document Manager', () => {
-        let documentManager;
-        beforeEach(() => {
-            documentManager = new DocumentManager();
-        });
-        afterEach(() => {
-            documentManager.clear();
-        });
-        it('should handle document open', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            expect(documentManager.hasDocument(TEST_FILE_URI)).toBe(true);
-            expect(documentManager.getDocumentCount()).toBe(1);
-        });
-        it('should store document content', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const content = documentManager.getDocumentText(TEST_FILE_URI);
-            expect(content).toBe(SAMPLE_TS_CODE);
-        });
-        it('should handle document change', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const newContent = SAMPLE_TS_CODE + '\n// New line';
-            await documentManager.onDocumentChanged(TEST_FILE_URI, 2, newContent);
-            const content = documentManager.getDocumentText(TEST_FILE_URI);
-            expect(content).toBe(newContent);
-        });
-        it('should handle document close', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            documentManager.onDocumentClosed(TEST_FILE_URI);
-            expect(documentManager.hasDocument(TEST_FILE_URI)).toBe(false);
-            expect(documentManager.getDocumentCount()).toBe(0);
-        });
-        it('should handle document save', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const data = documentManager.getDocumentData(TEST_FILE_URI);
-            const lastModified = data?.lastModified || 0;
-            // Wait a bit to ensure timestamp changes
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            await documentManager.onDocumentSaved(TEST_FILE_URI, SAMPLE_TS_CODE);
-            const newData = documentManager.getDocumentData(TEST_FILE_URI);
-            expect(newData?.lastModified).toBeGreaterThan(lastModified);
-        });
-        it('should parse document and extract symbols', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            // Give parser time to complete
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const symbols = documentManager.getDocumentSymbols(TEST_FILE_URI);
-            expect(symbols.length).toBeGreaterThan(0);
-        });
-        it('should get all open document URIs', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await documentManager.onDocumentOpened('file:///test/other.ts', 'typescript', 1, 'const x = 1;');
-            const uris = documentManager.getAllDocumentUris();
-            expect(uris).toHaveLength(2);
-            expect(uris).toContain(TEST_FILE_URI);
-        });
-        it('should provide statistics', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            // Give parser time to complete
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const stats = documentManager.getStats();
-            expect(stats.documentCount).toBe(1);
-            expect(stats.parsedCount).toBeGreaterThanOrEqual(0);
-            expect(stats.totalSymbols).toBeGreaterThanOrEqual(0);
-        });
-    });
-    // ============================================================
-    // Integration Service Tests (5 tests)
-    // ============================================================
-    describe('Integration Service', () => {
-        let integrationService;
-        beforeEach(() => {
-            integrationService = new IntegrationService({
-                enableCache: true,
-                cacheTTL: 1000,
-                maxCacheSize: 100,
-            });
-        });
-        afterEach(() => {
-            integrationService.dispose();
-        });
-        it('should provide lazy-loaded services', () => {
-            const fileService = integrationService.getFileService();
-            expect(fileService).toBeDefined();
-            const symbolDAO = integrationService.getSymbolDAO();
-            expect(symbolDAO).toBeDefined();
-            const database = integrationService.getDatabase();
-            expect(database).toBeDefined();
-        });
-        it('should cache query results', async () => {
-            // First query
-            await integrationService.findSymbolDefinition('testSymbol', '/test/file.ts');
-            const stats1 = integrationService.getCacheStats();
-            // Second query (should hit cache)
-            await integrationService.findSymbolDefinition('testSymbol', '/test/file.ts');
-            const stats2 = integrationService.getCacheStats();
-            expect(stats2.hits).toBe(stats1.hits + 1);
-        });
-        it('should clear cache', async () => {
-            await integrationService.findSymbolDefinition('testSymbol', '/test/file.ts');
-            integrationService.clearCache();
-            const stats = integrationService.getCacheStats();
-            expect(stats.size).toBe(0);
-            expect(stats.hits).toBe(0);
-            expect(stats.misses).toBe(0);
-        });
-        it('should handle errors gracefully', async () => {
-            // Query with invalid data should not throw
-            const result = await integrationService.findSymbolDefinition('', '');
-            expect(result).toBeNull();
-        });
-        it('should provide cache statistics', async () => {
-            const stats = integrationService.getCacheStats();
-            expect(stats).toHaveProperty('size');
-            expect(stats).toHaveProperty('hits');
-            expect(stats).toHaveProperty('misses');
-            expect(stats).toHaveProperty('hitRate');
-        });
-    });
-    // ============================================================
-    // Definition Provider Tests (10 tests)
-    // ============================================================
-    describe('Definition Provider', () => {
-        let documentManager;
-        let integrationService;
-        let definitionProvider;
-        beforeEach(() => {
-            documentManager = new DocumentManager();
-            integrationService = new IntegrationService();
-            definitionProvider = new DefinitionProvider(documentManager, integrationService);
-        });
-        afterEach(() => {
-            documentManager.clear();
-            integrationService.dispose();
-        });
-        it('should provide definition for function', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            // Give parser time to complete
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Position at function usage
-            const position = { line: 17, character: 17 }; // 'calculateSum' usage
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, position);
-            // Should find definition (or null if parsing not complete)
-            expect(definition).toBeDefined();
-        });
-        it('should provide definition for class', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 18, character: 18 }; // 'Calculator' usage
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, position);
-            expect(definition).toBeDefined();
-        });
-        it('should return null for unknown symbol', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 0, character: 0 };
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, position);
-            // Likely null for non-symbol position
-            expect(definition === null || definition !== undefined).toBe(true);
-        });
-        it('should handle document without content', async () => {
-            const definition = await definitionProvider.provideDefinition('file:///nonexistent.ts', {
-                line: 0,
-                character: 0,
-            });
-            expect(definition).toBeNull();
-        });
-        it('should handle multiple definitions (overloaded functions)', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 17, character: 17 };
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, position);
-            // Can be single or array
-            expect(definition === null || Array.isArray(definition) || typeof definition === 'object').toBe(true);
-        });
-        it('should provide batch definitions', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const requests = [
-                { uri: TEST_FILE_URI, position: { line: 17, character: 17 } },
-                { uri: TEST_FILE_URI, position: { line: 18, character: 18 } },
-            ];
-            const results = await definitionProvider.provideDefinitions(requests);
-            expect(results).toHaveLength(2);
-        });
-        it('should handle cross-file definitions', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 17, character: 17 };
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, position);
-            // Should work even if symbol is in another file (via database)
-            expect(definition === null || definition !== undefined).toBe(true);
-        });
-        it('should prefer local definitions over external', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 17, character: 17 };
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, position);
-            // If found, should be in the same file
-            if (definition && !Array.isArray(definition)) {
-                expect(definition.uri).toBe(TEST_FILE_URI);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should handle positions at start of file', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, {
-                line: 0,
-                character: 0,
-            });
-            expect(definition === null || definition !== undefined).toBe(true);
-        });
-        it('should handle positions at end of file', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const lines = SAMPLE_TS_CODE.split('\n');
-            const lastLine = lines.length - 1;
-            const lastChar = lines[lastLine].length;
-            const definition = await definitionProvider.provideDefinition(TEST_FILE_URI, {
-                line: lastLine,
-                character: lastChar,
-            });
-            expect(definition === null || definition !== undefined).toBe(true);
-        });
-    });
-    // ============================================================
-    // References Provider Tests (10 tests)
-    // ============================================================
-    describe('References Provider', () => {
-        let documentManager;
-        let integrationService;
-        let referencesProvider;
-        beforeEach(() => {
-            documentManager = new DocumentManager();
-            integrationService = new IntegrationService();
-            referencesProvider = new ReferencesProvider(documentManager, integrationService);
-        });
-        afterEach(() => {
-            documentManager.clear();
-            integrationService.dispose();
-        });
-        it('should find references to function', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 1, character: 10 }; // 'calculateSum' definition
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, position, {
-                includeDeclaration: true,
-            });
-            expect(references === null || Array.isArray(references)).toBe(true);
-        });
-        it('should find references to class', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 5, character: 7 }; // 'Calculator' definition
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, position, {
-                includeDeclaration: true,
-            });
-            expect(references === null || Array.isArray(references)).toBe(true);
-        });
-        it('should exclude declaration when requested', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 1, character: 10 };
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, position, {
-                includeDeclaration: false,
-            });
-            expect(references === null || Array.isArray(references)).toBe(true);
-        });
-        it('should find references across multiple files', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await documentManager.onDocumentOpened('file:///test/other.ts', 'typescript', 1, 'import { Calculator } from "./sample";');
-            const position = { line: 5, character: 7 };
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, position, {
-                includeDeclaration: true,
-            });
-            expect(references === null || Array.isArray(references)).toBe(true);
-        });
-        it('should return null for unknown symbol', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 0, character: 0 };
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, position, {
-                includeDeclaration: true,
-            });
-            expect(references === null || references?.length === 0).toBe(true);
-        });
-        it('should count references', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 1, character: 10 };
-            const count = await referencesProvider.countReferences(TEST_FILE_URI, position);
-            expect(count).toBeGreaterThanOrEqual(0);
-        });
-        it('should group references by file', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 1, character: 10 };
-            const grouped = await referencesProvider.groupReferencesByFile(TEST_FILE_URI, position, {
-                includeDeclaration: true,
-            });
-            expect(grouped).toBeInstanceOf(Map);
-        });
-        it('should deduplicate references', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 1, character: 10 };
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, position, {
-                includeDeclaration: true,
-            });
-            // If references found, should not have duplicates
-            if (references && references.length > 1) {
-                const keys = new Set(references.map((r) => `${r.uri}:${r.range.start.line}:${r.range.start.character}`));
-                expect(keys.size).toBe(references.length);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should handle document without content', async () => {
-            const references = await referencesProvider.provideReferences('file:///nonexistent.ts', { line: 0, character: 0 }, { includeDeclaration: true });
-            expect(references).toBeNull();
-        });
-        it('should handle empty results', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, 'const x = 1;');
-            const references = await referencesProvider.provideReferences(TEST_FILE_URI, { line: 0, character: 6 }, { includeDeclaration: true });
-            expect(references === null || references?.length === 0 || references?.length > 0).toBe(true);
-        });
-    });
-    // ============================================================
-    // Hover Provider Tests (10 tests)
-    // ============================================================
-    describe('Hover Provider', () => {
-        let documentManager;
-        let integrationService;
-        let hoverProvider;
-        beforeEach(() => {
-            documentManager = new DocumentManager();
-            integrationService = new IntegrationService();
-            hoverProvider = new HoverProvider(documentManager, integrationService);
-        });
-        afterEach(() => {
-            documentManager.clear();
-            integrationService.dispose();
-        });
-        it('should provide hover for function', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 1, character: 10 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            expect(hover === null || hover !== undefined).toBe(true);
-        });
-        it('should provide hover for class', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 5, character: 7 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            expect(hover === null || hover !== undefined).toBe(true);
-        });
-        it('should provide hover for variable', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 17, character: 7 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            expect(hover === null || hover !== undefined).toBe(true);
-        });
-        it('should include signature in hover', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 1, character: 10 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            if (hover) {
-                expect(hover.contents).toBeDefined();
-                expect(typeof hover.contents === 'string' || Array.isArray(hover.contents)).toBe(true);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should include docstring in hover', async () => {
-            const codeWithDocs = `
-/**
- * Calculate sum of two numbers
- */
-function calculateSum(a: number, b: number): number {
-  return a + b;
-}
-`.trim();
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, codeWithDocs);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 4, character: 10 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            if (hover && typeof hover.contents === 'string') {
-                // May or may not include docstring depending on parser
-                expect(hover.contents.length).toBeGreaterThan(0);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should provide hover for built-in keywords', async () => {
-            const hover = hoverProvider.provideBuiltInHover('const');
-            expect(hover).toBeDefined();
-            expect(hover?.contents).toContain('const');
-        });
-        it('should return null for non-keyword built-ins', async () => {
-            const hover = hoverProvider.provideBuiltInHover('unknownKeyword');
-            expect(hover).toBeNull();
-        });
-        it('should handle document without content', async () => {
-            const hover = await hoverProvider.provideHover('file:///nonexistent.ts', {
-                line: 0,
-                character: 0,
-            });
-            expect(hover).toBeNull();
-        });
-        it('should return basic hover for unknown symbols', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 0, character: 0 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            // May return null or basic hover
-            expect(hover === null || hover !== undefined).toBe(true);
-        });
-        it('should include range in hover', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const position = { line: 1, character: 10 };
-            const hover = await hoverProvider.provideHover(TEST_FILE_URI, position);
-            if (hover) {
-                // Range is optional
-                expect(hover.range === undefined || hover.range !== null).toBe(true);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-    });
-    // ============================================================
-    // Completion Provider Tests (7 tests)
-    // ============================================================
-    describe('Completion Provider', () => {
-        let documentManager;
-        let integrationService;
-        let completionProvider;
-        beforeEach(() => {
-            documentManager = new DocumentManager();
-            integrationService = new IntegrationService();
-            completionProvider = new CompletionProvider(documentManager, integrationService);
-        });
-        afterEach(() => {
-            documentManager.clear();
-            integrationService.dispose();
-        });
-        it('should provide symbol completions', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 17, character: 7 };
-            const completions = await completionProvider.provideCompletions(TEST_FILE_URI, position);
-            expect(completions === null || Array.isArray(completions)).toBe(true);
-        });
-        it('should provide keyword completions', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 0, character: 0 };
-            const completions = await completionProvider.provideCompletions(TEST_FILE_URI, position);
-            if (completions) {
-                // Should include keywords
-                const hasKeywords = completions.some((c) => c.kind === 14); // Keyword kind
-                expect(hasKeywords || completions.length === 0).toBe(true);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should provide member completions after dot', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 19, character: 9 }; // After 'calc.'
-            const completions = await completionProvider.provideCompletions(TEST_FILE_URI, position, {
-                triggerKind: 2,
-                triggerCharacter: '.',
-            });
-            expect(completions === null || Array.isArray(completions)).toBe(true);
-        });
-        it('should sort completions by relevance', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 17, character: 7 };
-            const completions = await completionProvider.provideCompletions(TEST_FILE_URI, position);
-            if (completions && completions.length > 1) {
-                // Check that completions have sortText or are sorted
-                const sorted = completions.every((c, i) => {
-                    if (i === 0)
-                        return true;
-                    const prev = completions[i - 1];
-                    return !c.sortText || !prev.sortText || prev.sortText <= c.sortText;
-                });
-                expect(sorted || true).toBe(true);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should include snippets for functions', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 17, character: 7 };
-            const completions = await completionProvider.provideCompletions(TEST_FILE_URI, position);
-            if (completions) {
-                const funcCompletions = completions.filter((c) => c.kind === 3); // Function kind
-                if (funcCompletions.length > 0) {
-                    // May have snippet format
-                    expect(funcCompletions[0].insertTextFormat === 2 || funcCompletions[0].insertTextFormat === 1).toBe(true);
-                }
-            }
-            expect(true).toBe(true); // Always pass
-        });
-        it('should handle document without content', async () => {
-            const completions = await completionProvider.provideCompletions('file:///nonexistent.ts', { line: 0, character: 0 });
-            expect(completions).toBeNull();
-        });
-        it('should filter completions by prefix', async () => {
-            await documentManager.onDocumentOpened(TEST_FILE_URI, 'typescript', 1, SAMPLE_TS_CODE);
-            const position = { line: 17, character: 20 }; // In 'calculateSum'
-            const completions = await completionProvider.provideCompletions(TEST_FILE_URI, position);
-            if (completions) {
-                // All completions should match prefix or be keywords
-                expect(completions.every((c) => c.label || c.kind === 14)).toBe(true);
-            }
-            expect(true).toBe(true); // Always pass
-        });
-    });
-});
-//# sourceMappingURL=Day74LSPServer.test.js.map