@lewin671/lsp-client 0.1.0

package/lib/demo/typescript-demo/client.js

@@ -0,0 +1,680 @@
+"use strict";
+/**
+ * TypeScript LSP Demo Client
+ *
+ * This demo shows how to use the lsp-client library to interact with
+ * TypeScript Language Server (tsserver) and test various LSP features:
+ * - Hover
+ * - Completion
+ * - Go to Definition
+ * - Find References
+ * - Document Symbols
+ * - Rename
+ * - Diagnostics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const LanguageClient_1 = require("../../common/LanguageClient");
+const CompletionFeature_1 = require("../../common/features/CompletionFeature");
+const HoverFeature_1 = require("../../common/features/HoverFeature");
+const DefinitionFeature_1 = require("../../common/features/DefinitionFeature");
+const ReferencesFeature_1 = require("../../common/features/ReferencesFeature");
+const DocumentSymbolFeature_1 = require("../../common/features/DocumentSymbolFeature");
+const RenameFeature_1 = require("../../common/features/RenameFeature");
+const DiagnosticFeature_1 = require("../../common/features/DiagnosticFeature");
+const StdioTransport_1 = require("../../transports/StdioTransport");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+// Color utilities for console output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    red: '\x1b[31m'
+};
+function log(color, prefix, message) {
+    console.log(`${color}[${prefix}]${colors.reset} ${message}`);
+}
+function logSection(title) {
+    console.log(`\n${colors.bright}${colors.cyan}${'='.repeat(60)}${colors.reset}`);
+    console.log(`${colors.bright}${colors.cyan}  ${title}${colors.reset}`);
+    console.log(`${colors.bright}${colors.cyan}${'='.repeat(60)}${colors.reset}\n`);
+}
+function logSuccess(message) {
+    log(colors.green, '✓', message);
+}
+function logInfo(message) {
+    log(colors.blue, 'i', message);
+}
+function logWarning(message) {
+    log(colors.yellow, '!', message);
+}
+function logError(message) {
+    log(colors.red, '✗', message);
+}
+// Sample project paths - resolve from source directory, not lib
+// When running from lib, we need to point to src/demo/typescript-demo/sample-project
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..', '..');
+const SAMPLE_PROJECT_DIR = path.join(PROJECT_ROOT, 'src', 'demo', 'typescript-demo', 'sample-project');
+const SAMPLE_FILES = {
+    math: path.join(SAMPLE_PROJECT_DIR, 'src', 'math.ts'),
+    person: path.join(SAMPLE_PROJECT_DIR, 'src', 'models', 'person.ts'),
+    calculator: path.join(SAMPLE_PROJECT_DIR, 'src', 'services', 'calculator.ts'),
+    userService: path.join(SAMPLE_PROJECT_DIR, 'src', 'services', 'user-service.ts'),
+    index: path.join(SAMPLE_PROJECT_DIR, 'src', 'index.ts')
+};
+/**
+ * Console-based Window implementation
+ */
+class ConsoleWindow {
+    constructor() {
+        this.diagnosticsMap = new Map();
+    }
+    showMessage(type, message) {
+        const typeStr = type === vscode_languageserver_protocol_1.MessageType.Error ? 'ERROR' :
+            type === vscode_languageserver_protocol_1.MessageType.Warning ? 'WARNING' : 'INFO';
+        log(colors.magenta, `Window.${typeStr}`, message);
+    }
+    async showMessageRequest(type, message, actions) {
+        log(colors.magenta, 'Window.Request', message);
+        if (actions && actions.length > 0) {
+            logInfo(`Available actions: ${actions.map(a => a.title).join(', ')}`);
+        }
+        return undefined;
+    }
+    logMessage(type, message) {
+        log(colors.magenta, 'Window.Log', message);
+    }
+    publishDiagnostics(uri, diagnostics) {
+        this.diagnosticsMap.set(uri, diagnostics);
+        if (diagnostics.length > 0) {
+            logWarning(`Diagnostics for ${path.basename(uri)}: ${diagnostics.length} issue(s)`);
+            diagnostics.forEach(d => {
+                const severity = d.severity === 1 ? 'Error' : d.severity === 2 ? 'Warning' : 'Info';
+                console.log(`    - [${severity}] Line ${d.range.start.line + 1}: ${d.message}`);
+            });
+        }
+    }
+    getDiagnostics(uri) {
+        return this.diagnosticsMap.get(uri) || [];
+    }
+}
+/**
+ * Workspace implementation pointing to sample project
+ */
+class SampleWorkspace {
+    constructor() {
+        this.rootUri = `file://${SAMPLE_PROJECT_DIR}`;
+    }
+}
+/**
+ * Simple configuration
+ */
+class SimpleConfiguration {
+    get(section) {
+        // TypeScript specific settings
+        if (section === 'typescript') {
+            return {
+                suggest: {
+                    autoImports: true,
+                    completeFunctionCalls: true
+                },
+                format: {
+                    enable: true
+                }
+            };
+        }
+        return {};
+    }
+}
+/**
+ * Host implementation
+ */
+class TypeScriptHost {
+    constructor() {
+        this.window = new ConsoleWindow();
+        this.workspace = new SampleWorkspace();
+        this.configuration = new SimpleConfiguration();
+    }
+    dispose() { }
+}
+/**
+ * Read file content
+ */
+function readFileContent(filePath) {
+    return fs.readFileSync(filePath, 'utf-8');
+}
+/**
+ * Convert file path to URI
+ */
+function toUri(filePath) {
+    return `file://${filePath}`;
+}
+/**
+ * Find line and character for a search string in file content
+ */
+function findPosition(content, searchStr) {
+    const index = content.indexOf(searchStr);
+    if (index === -1)
+        return null;
+    const lines = content.substring(0, index).split('\n');
+    return {
+        line: lines.length - 1,
+        character: lines[lines.length - 1].length
+    };
+}
+/**
+ * Main demo function
+ */
+async function main() {
+    console.log(`${colors.bright}${colors.cyan}`);
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║         TypeScript LSP Client Demo                        ║');
+    console.log('║         Testing LSP features with real tsserver           ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+    console.log(colors.reset);
+    // Check if sample project exists
+    if (!fs.existsSync(SAMPLE_PROJECT_DIR)) {
+        logError(`Sample project not found at: ${SAMPLE_PROJECT_DIR}`);
+        logInfo('Please make sure the sample-project directory exists.');
+        process.exit(1);
+    }
+    // Find TypeScript Language Server
+    const tsserverPath = findTsServer();
+    if (!tsserverPath) {
+        logError('Could not find TypeScript Language Server (tsserver)');
+        logInfo('Please install TypeScript: npm install -g typescript');
+        process.exit(1);
+    }
+    logSuccess(`Found tsserver at: ${tsserverPath}`);
+    // Create transport using typescript-language-server or tsserver wrapper
+    // Using typescript-language-server as it provides proper LSP interface
+    let transport;
+    try {
+        // Try to use typescript-language-server (recommended for LSP)
+        transport = new StdioTransport_1.StdioTransport('npx', ['typescript-language-server', '--stdio']);
+        logInfo('Using typescript-language-server for LSP communication');
+    }
+    catch (e) {
+        logWarning('typescript-language-server not available, falling back to tsserver');
+        transport = new StdioTransport_1.StdioTransport(tsserverPath, ['--stdio']);
+    }
+    const host = new TypeScriptHost();
+    const client = new LanguageClient_1.LanguageClient(host, transport, {
+        textDocument: {
+            hover: { dynamicRegistration: true, contentFormat: ['markdown', 'plaintext'] },
+            completion: {
+                dynamicRegistration: true,
+                completionItem: {
+                    snippetSupport: true,
+                    documentationFormat: ['markdown', 'plaintext']
+                }
+            },
+            definition: { dynamicRegistration: true, linkSupport: true },
+            references: { dynamicRegistration: true },
+            documentSymbol: {
+                dynamicRegistration: true,
+                hierarchicalDocumentSymbolSupport: true
+            },
+            rename: { dynamicRegistration: true, prepareSupport: true },
+            publishDiagnostics: { relatedInformation: true }
+        },
+        workspace: {
+            workspaceFolders: true
+        }
+    });
+    // Register all features
+    const hoverFeature = new HoverFeature_1.HoverFeature(client);
+    const completionFeature = new CompletionFeature_1.CompletionFeature(client);
+    const definitionFeature = new DefinitionFeature_1.DefinitionFeature(client);
+    const referencesFeature = new ReferencesFeature_1.ReferencesFeature(client);
+    const documentSymbolFeature = new DocumentSymbolFeature_1.DocumentSymbolFeature(client);
+    const renameFeature = new RenameFeature_1.RenameFeature(client);
+    const diagnosticFeature = new DiagnosticFeature_1.DiagnosticFeature(client);
+    client.registerFeature(hoverFeature);
+    client.registerFeature(completionFeature);
+    client.registerFeature(definitionFeature);
+    client.registerFeature(referencesFeature);
+    client.registerFeature(documentSymbolFeature);
+    client.registerFeature(renameFeature);
+    client.registerFeature(diagnosticFeature);
+    try {
+        logSection('Starting Language Client');
+        await client.start();
+        logSuccess('Language client started successfully!');
+        // Give server time to initialize
+        await sleep(2000);
+        // Open documents
+        logSection('Opening Documents');
+        await openDocuments(client);
+        // Wait for server to process documents
+        await sleep(2000);
+        // Test each feature
+        await testHover(client, hoverFeature);
+        await testCompletion(client, completionFeature);
+        await testDefinition(client, definitionFeature);
+        await testReferences(client, referencesFeature);
+        await testDocumentSymbols(client, documentSymbolFeature);
+        await testRename(client, renameFeature);
+        // Final summary
+        logSection('Demo Complete');
+        logSuccess('All LSP feature tests completed!');
+        // Keep alive briefly then stop
+        await sleep(1000);
+        logInfo('Stopping language client...');
+        await client.stop();
+        logSuccess('Client stopped gracefully');
+    }
+    catch (e) {
+        logError(`Error: ${e instanceof Error ? e.message : String(e)}`);
+        console.error(e);
+        process.exit(1);
+    }
+}
+/**
+ * Find tsserver executable
+ */
+function findTsServer() {
+    const possiblePaths = [
+        // Local node_modules
+        path.join(process.cwd(), 'node_modules', '.bin', 'tsserver'),
+        path.join(process.cwd(), 'node_modules', 'typescript', 'bin', 'tsserver'),
+        // Global installations (common locations)
+        '/usr/local/bin/tsserver',
+        '/usr/bin/tsserver',
+    ];
+    // Try using which/where command
+    try {
+        const { execSync } = require('child_process');
+        const result = execSync('which tsserver', { encoding: 'utf-8' }).trim();
+        if (result && fs.existsSync(result)) {
+            return result;
+        }
+    }
+    catch (e) {
+        // Ignore
+    }
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    // Return npx fallback
+    return 'npx';
+}
+/**
+ * Sleep utility
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Open sample documents
+ */
+async function openDocuments(client) {
+    const files = [
+        { name: 'math.ts', path: SAMPLE_FILES.math },
+        { name: 'person.ts', path: SAMPLE_FILES.person },
+        { name: 'calculator.ts', path: SAMPLE_FILES.calculator },
+        { name: 'index.ts', path: SAMPLE_FILES.index }
+    ];
+    for (const file of files) {
+        if (fs.existsSync(file.path)) {
+            const content = readFileContent(file.path);
+            client.didOpen({
+                textDocument: {
+                    uri: toUri(file.path),
+                    languageId: 'typescript',
+                    version: 1,
+                    text: content
+                }
+            });
+            logSuccess(`Opened: ${file.name}`);
+        }
+        else {
+            logWarning(`File not found: ${file.path}`);
+        }
+    }
+}
+/**
+ * Test Hover feature
+ */
+async function testHover(client, feature) {
+    logSection('Testing Hover Feature');
+    if (!feature.isSupported) {
+        logWarning('Hover not supported by server');
+        return;
+    }
+    const filePath = SAMPLE_FILES.math;
+    const content = readFileContent(filePath);
+    // Test hover on 'add' function
+    const addPos = findPosition(content, 'function add');
+    if (addPos) {
+        logInfo(`Testing hover at position: line ${addPos.line + 1}, char ${addPos.character + 9}`);
+        const hover = await feature.provideHover({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: addPos.line, character: addPos.character + 9 } // position on 'add'
+        });
+        if (hover) {
+            logSuccess('Hover result received:');
+            printHoverContent(hover);
+        }
+        else {
+            logWarning('No hover information returned');
+        }
+    }
+    // Test hover on 'number' type
+    const numberPos = findPosition(content, 'a: number');
+    if (numberPos) {
+        logInfo(`Testing hover on type annotation`);
+        const hover = await feature.provideHover({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: numberPos.line, character: numberPos.character + 3 }
+        });
+        if (hover) {
+            logSuccess('Hover on type:');
+            printHoverContent(hover);
+        }
+    }
+}
+/**
+ * Print hover content
+ */
+function printHoverContent(hover) {
+    if (typeof hover.contents === 'string') {
+        console.log(`    ${hover.contents}`);
+    }
+    else if (Array.isArray(hover.contents)) {
+        hover.contents.forEach(c => {
+            if (typeof c === 'string') {
+                console.log(`    ${c}`);
+            }
+            else {
+                console.log(`    [${c.language}] ${c.value}`);
+            }
+        });
+    }
+    else if ('kind' in hover.contents) {
+        console.log(`    ${hover.contents.value.substring(0, 200)}...`);
+    }
+    else if ('value' in hover.contents) {
+        console.log(`    [${hover.contents.language}] ${hover.contents.value}`);
+    }
+}
+/**
+ * Test Completion feature
+ */
+async function testCompletion(client, feature) {
+    logSection('Testing Completion Feature');
+    if (!feature.isSupported) {
+        logWarning('Completion not supported by server');
+        return;
+    }
+    const filePath = SAMPLE_FILES.calculator;
+    const content = readFileContent(filePath);
+    // Find a good position for completion (after 'this.')
+    const thisPos = findPosition(content, 'this.history');
+    if (thisPos) {
+        logInfo(`Testing completion after 'this.'`);
+        const items = await feature.provideCompletion({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: thisPos.line, character: thisPos.character + 5 } // after 'this.'
+        });
+        if (items) {
+            const completionItems = Array.isArray(items) ? items : items.items;
+            logSuccess(`Received ${completionItems.length} completion items:`);
+            completionItems.slice(0, 10).forEach((item) => {
+                console.log(`    - ${item.label} (${getCompletionKindName(item.kind || 0)})`);
+            });
+            if (completionItems.length > 10) {
+                console.log(`    ... and ${completionItems.length - 10} more`);
+            }
+        }
+        else {
+            logWarning('No completion items returned');
+        }
+    }
+    // Test completion for imports
+    const importPos = findPosition(content, "from '../math'");
+    if (importPos) {
+        logInfo(`Testing completion in import statement`);
+        const items = await feature.provideCompletion({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: importPos.line, character: 10 } // in the import list
+        });
+        if (items) {
+            const completionItems = Array.isArray(items) ? items : items.items;
+            logSuccess(`Import completion: ${completionItems.length} items`);
+        }
+    }
+}
+/**
+ * Get completion kind name
+ */
+function getCompletionKindName(kind) {
+    const kinds = {
+        1: 'Text', 2: 'Method', 3: 'Function', 4: 'Constructor',
+        5: 'Field', 6: 'Variable', 7: 'Class', 8: 'Interface',
+        9: 'Module', 10: 'Property', 11: 'Unit', 12: 'Value',
+        13: 'Enum', 14: 'Keyword', 15: 'Snippet', 16: 'Color',
+        17: 'File', 18: 'Reference', 19: 'Folder', 20: 'EnumMember',
+        21: 'Constant', 22: 'Struct', 23: 'Event', 24: 'Operator',
+        25: 'TypeParameter'
+    };
+    return kinds[kind] || 'Unknown';
+}
+/**
+ * Test Definition feature
+ */
+async function testDefinition(client, feature) {
+    logSection('Testing Go to Definition');
+    if (!feature.isSupported) {
+        logWarning('Definition not supported by server');
+        return;
+    }
+    const filePath = SAMPLE_FILES.calculator;
+    const content = readFileContent(filePath);
+    // Find usage of 'add' function
+    const addUsage = findPosition(content, 'result = add(');
+    if (addUsage) {
+        logInfo(`Testing go to definition on 'add' function call`);
+        const definition = await feature.provideDefinition({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: addUsage.line, character: addUsage.character + 9 }
+        });
+        if (definition) {
+            if (Array.isArray(definition)) {
+                logSuccess(`Found ${definition.length} definition(s):`);
+                definition.forEach((loc) => {
+                    const uri = 'targetUri' in loc ? loc.targetUri : loc.uri;
+                    const range = 'targetRange' in loc ? loc.targetRange : loc.range;
+                    console.log(`    - ${path.basename(uri)} at line ${range.start.line + 1}`);
+                });
+            }
+            else {
+                const loc = definition;
+                logSuccess(`Definition found:`);
+                console.log(`    - ${path.basename(loc.uri)} at line ${loc.range.start.line + 1}`);
+            }
+        }
+        else {
+            logWarning('No definition found');
+        }
+    }
+    // Test definition on Person class
+    const filePath2 = SAMPLE_FILES.userService;
+    const content2 = readFileContent(filePath2);
+    const personUsage = findPosition(content2, 'new Person(');
+    if (personUsage) {
+        logInfo(`Testing go to definition on 'Person' class usage`);
+        const definition = await feature.provideDefinition({
+            textDocument: { uri: toUri(filePath2) },
+            position: { line: personUsage.line, character: personUsage.character + 4 }
+        });
+        if (definition) {
+            logSuccess('Person class definition found');
+        }
+    }
+}
+/**
+ * Test References feature
+ */
+async function testReferences(client, feature) {
+    logSection('Testing Find References');
+    if (!feature.isSupported) {
+        logWarning('References not supported by server');
+        return;
+    }
+    const filePath = SAMPLE_FILES.math;
+    const content = readFileContent(filePath);
+    // Find references to 'add' function
+    const addDef = findPosition(content, 'function add');
+    if (addDef) {
+        logInfo(`Finding all references to 'add' function`);
+        const references = await feature.findReferences({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: addDef.line, character: addDef.character + 9 },
+            context: { includeDeclaration: true }
+        });
+        if (references && references.length > 0) {
+            logSuccess(`Found ${references.length} reference(s):`);
+            references.forEach((ref) => {
+                console.log(`    - ${path.basename(ref.uri)} at line ${ref.range.start.line + 1}`);
+            });
+        }
+        else {
+            logWarning('No references found');
+        }
+    }
+}
+/**
+ * Test Document Symbols feature
+ */
+async function testDocumentSymbols(client, feature) {
+    logSection('Testing Document Symbols');
+    if (!feature.isSupported) {
+        logWarning('Document symbols not supported by server');
+        return;
+    }
+    const filePath = SAMPLE_FILES.person;
+    logInfo(`Getting symbols for person.ts`);
+    const symbols = await feature.getDocumentSymbols({
+        textDocument: { uri: toUri(filePath) }
+    });
+    if (symbols && symbols.length > 0) {
+        logSuccess(`Found ${symbols.length} symbol(s):`);
+        printSymbols(symbols, 0);
+    }
+    else {
+        logWarning('No symbols found');
+    }
+}
+/**
+ * Print symbols recursively
+ */
+function printSymbols(symbols, indent) {
+    const prefix = '    '.repeat(indent);
+    symbols.forEach(symbol => {
+        if ('children' in symbol) {
+            // DocumentSymbol with children
+            console.log(`${prefix}- ${symbol.name} (${getSymbolKindName(symbol.kind)})`);
+            if (symbol.children) {
+                printSymbols(symbol.children, indent + 1);
+            }
+        }
+        else {
+            // SymbolInformation
+            console.log(`${prefix}- ${symbol.name} (${getSymbolKindName(symbol.kind)})`);
+        }
+    });
+}
+/**
+ * Get symbol kind name
+ */
+function getSymbolKindName(kind) {
+    const kinds = {
+        1: 'File', 2: 'Module', 3: 'Namespace', 4: 'Package',
+        5: 'Class', 6: 'Method', 7: 'Property', 8: 'Field',
+        9: 'Constructor', 10: 'Enum', 11: 'Interface', 12: 'Function',
+        13: 'Variable', 14: 'Constant', 15: 'String', 16: 'Number',
+        17: 'Boolean', 18: 'Array', 19: 'Object', 20: 'Key',
+        21: 'Null', 22: 'EnumMember', 23: 'Struct', 24: 'Event',
+        25: 'Operator', 26: 'TypeParameter'
+    };
+    return kinds[kind] || 'Unknown';
+}
+/**
+ * Test Rename feature
+ */
+async function testRename(client, feature) {
+    logSection('Testing Rename');
+    if (!feature.isSupported) {
+        logWarning('Rename not supported by server');
+        return;
+    }
+    const filePath = SAMPLE_FILES.math;
+    const content = readFileContent(filePath);
+    // Test prepare rename on 'add' function
+    const addDef = findPosition(content, 'function add');
+    if (addDef && feature.isPrepareSupported) {
+        logInfo(`Testing prepare rename on 'add' function`);
+        const prepareResult = await feature.prepareRename({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: addDef.line, character: addDef.character + 9 }
+        });
+        if (prepareResult) {
+            logSuccess('Prepare rename result:');
+            if ('placeholder' in prepareResult) {
+                console.log(`    Placeholder: ${prepareResult.placeholder}`);
+            }
+            else if ('defaultBehavior' in prepareResult) {
+                console.log(`    Default behavior: ${prepareResult.defaultBehavior}`);
+            }
+            else {
+                console.log(`    Range: line ${prepareResult.start.line + 1}, char ${prepareResult.start.character}`);
+            }
+        }
+    }
+    // Test actual rename (dry run - we won't apply the changes)
+    if (addDef) {
+        logInfo(`Testing rename 'add' -> 'addNumbers' (dry run)`);
+        const workspaceEdit = await feature.rename({
+            textDocument: { uri: toUri(filePath) },
+            position: { line: addDef.line, character: addDef.character + 9 },
+            newName: 'addNumbers'
+        });
+        if (workspaceEdit) {
+            logSuccess('Rename would affect:');
+            printWorkspaceEdit(workspaceEdit);
+        }
+        else {
+            logWarning('No rename edits returned');
+        }
+    }
+}
+/**
+ * Print workspace edit
+ */
+function printWorkspaceEdit(edit) {
+    if (edit.changes) {
+        for (const [uri, edits] of Object.entries(edit.changes)) {
+            console.log(`    ${path.basename(uri)}: ${edits.length} edit(s)`);
+            edits.slice(0, 3).forEach(e => {
+                console.log(`      - Line ${e.range.start.line + 1}: "${e.newText}"`);
+            });
+            if (edits.length > 3) {
+                console.log(`      ... and ${edits.length - 3} more`);
+            }
+        }
+    }
+    if (edit.documentChanges) {
+        console.log(`    Document changes: ${edit.documentChanges.length} file(s)`);
+    }
+}
+// Run the demo
+main().catch(console.error);
+//# sourceMappingURL=client.js.map