@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/services/lsp-client.js

@@ -0,0 +1,667 @@
+/**
+ * LSP WebSocket Client
+ * Communicates with a language server via WebSocket + JSON-RPC
+ */
+// ============================================================================
+// Default Client Capabilities
+// ============================================================================
+const DEFAULT_CLIENT_CAPABILITIES = {
+    workspace: {
+        applyEdit: true,
+        workspaceEdit: { documentChanges: true },
+        didChangeConfiguration: { dynamicRegistration: true },
+        didChangeWatchedFiles: { dynamicRegistration: true },
+        symbol: { dynamicRegistration: true },
+        executeCommand: { dynamicRegistration: true },
+        workspaceFolders: true,
+        configuration: true
+    },
+    textDocument: {
+        synchronization: {
+            dynamicRegistration: true,
+            willSave: true,
+            willSaveWaitUntil: true,
+            didSave: true
+        },
+        completion: {
+            dynamicRegistration: true,
+            completionItem: {
+                snippetSupport: true,
+                commitCharactersSupport: true,
+                documentationFormat: ['markdown', 'plaintext'],
+                deprecatedSupport: true,
+                preselectSupport: true,
+                insertReplaceSupport: true,
+                labelDetailsSupport: true
+            },
+            contextSupport: true
+        },
+        hover: {
+            dynamicRegistration: true,
+            contentFormat: ['markdown', 'plaintext']
+        },
+        signatureHelp: {
+            dynamicRegistration: true,
+            signatureInformation: {
+                documentationFormat: ['markdown', 'plaintext'],
+                parameterInformation: { labelOffsetSupport: true }
+            },
+            contextSupport: true
+        },
+        definition: { dynamicRegistration: true, linkSupport: true },
+        typeDefinition: { dynamicRegistration: true, linkSupport: true },
+        implementation: { dynamicRegistration: true, linkSupport: true },
+        references: { dynamicRegistration: true },
+        documentHighlight: { dynamicRegistration: true },
+        documentSymbol: { dynamicRegistration: true },
+        codeAction: {
+            dynamicRegistration: true,
+            codeActionLiteralSupport: {
+                codeActionKind: {
+                    valueSet: [
+                        'quickfix',
+                        'refactor',
+                        'refactor.extract',
+                        'refactor.inline',
+                        'refactor.rewrite',
+                        'source',
+                        'source.organizeImports',
+                        'source.fixAll'
+                    ]
+                }
+            },
+            isPreferredSupport: true,
+            disabledSupport: true,
+            dataSupport: true,
+            resolveSupport: { properties: ['edit'] }
+        },
+        codeLens: { dynamicRegistration: true },
+        formatting: { dynamicRegistration: true },
+        rangeFormatting: { dynamicRegistration: true },
+        onTypeFormatting: { dynamicRegistration: true },
+        rename: { dynamicRegistration: true, prepareSupport: true },
+        publishDiagnostics: {
+            relatedInformation: true,
+            tagSupport: { valueSet: [1, 2] },
+            versionSupport: true,
+            codeDescriptionSupport: true,
+            dataSupport: true
+        }
+    },
+    window: {
+        workDoneProgress: true,
+        showMessage: { messageActionItem: { additionalPropertiesSupport: true } },
+        showDocument: { support: true }
+    }
+};
+// ============================================================================
+// LSP Client Class
+// ============================================================================
+export class LSPClient {
+    config;
+    ws = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    // Each method may have multiple subscribers; store a Set so subscribing does
+    // not clobber an existing handler and unsubscribing removes only its own.
+    notificationHandlers = new Map();
+    _state = 'disconnected';
+    _capabilities = null;
+    reconnectAttempts = 0;
+    reconnectTimeout = null;
+    // Document tracking
+    openDocuments = new Map();
+    diagnosticsCache = new Map();
+    // Event handlers. Each event may have multiple subscribers; store a Set per
+    // event so on() does not overwrite a prior handler and the returned
+    // unsubscribe removes only the specific callback it registered.
+    eventHandlers = {};
+    constructor(config) {
+        this.config = config;
+        // Set defaults
+        this.config = {
+            autoReconnect: true,
+            reconnectDelay: 1000,
+            maxReconnectAttempts: 5,
+            requestTimeout: 30000,
+            debug: false,
+            ...config
+        };
+        // Register built-in notification handlers
+        this.onNotification('textDocument/publishDiagnostics', (params) => {
+            const diagnosticsParams = params;
+            this.diagnosticsCache.set(diagnosticsParams.uri, diagnosticsParams.diagnostics);
+            this.emitEvent('onDiagnostics', diagnosticsParams);
+        });
+    }
+    // ============================================================================
+    // Connection Management
+    // ============================================================================
+    get state() {
+        return this._state;
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    get isReady() {
+        return this._state === 'ready';
+    }
+    /**
+     * Dispatch an event to every subscriber registered via on(). Iterates a copy
+     * so a handler that unsubscribes during dispatch cannot corrupt iteration,
+     * and isolates handler errors so one failure does not block the others.
+     */
+    emitEvent(event, ...args) {
+        const handlers = this.eventHandlers[event];
+        if (!handlers)
+            return;
+        for (const handler of [...handlers]) {
+            try {
+                handler(...args);
+            }
+            catch (err) {
+                if (this.config.debug) {
+                    console.error(`[LSP] Event handler for "${String(event)}" threw:`, err);
+                }
+            }
+        }
+    }
+    setState(state) {
+        this._state = state;
+        this.emitEvent('onConnectionStateChange', state);
+        if (this.config.debug) {
+            console.log(`[LSP] State changed to: ${state}`);
+        }
+    }
+    async connect() {
+        if (this._state !== 'disconnected' && this._state !== 'error') {
+            return;
+        }
+        this.setState('connecting');
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.config.serverUrl);
+                this.ws.onopen = async () => {
+                    this.reconnectAttempts = 0;
+                    this.setState('connected');
+                    try {
+                        await this.initialize();
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                };
+                this.ws.onclose = () => {
+                    this.handleDisconnect();
+                };
+                this.ws.onerror = (event) => {
+                    const error = new Error('WebSocket error');
+                    this.emitEvent('onError', error);
+                    if (this._state === 'connecting') {
+                        reject(error);
+                    }
+                };
+                this.ws.onmessage = (event) => {
+                    this.handleMessage(event.data);
+                };
+            }
+            catch (err) {
+                this.setState('error');
+                reject(err);
+            }
+        });
+    }
+    handleDisconnect() {
+        this.setState('disconnected');
+        // Cancel pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Connection closed'));
+        }
+        this.pendingRequests.clear();
+        // Auto-reconnect
+        if (this.config.autoReconnect &&
+            this.reconnectAttempts < (this.config.maxReconnectAttempts ?? 5)) {
+            this.reconnectAttempts++;
+            const delay = (this.config.reconnectDelay ?? 1000) * this.reconnectAttempts;
+            if (this.config.debug) {
+                console.log(`[LSP] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+            }
+            this.reconnectTimeout = setTimeout(() => {
+                this.connect().catch((err) => {
+                    this.emitEvent('onError', err);
+                });
+            }, delay);
+        }
+    }
+    async disconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.ws) {
+            // Send shutdown request
+            if (this._state === 'ready') {
+                try {
+                    await this.sendRequest('shutdown', null);
+                    this.sendNotification('exit', null);
+                }
+                catch {
+                    // Ignore errors during shutdown
+                }
+            }
+            this.ws.close();
+            this.ws = null;
+        }
+        this.setState('disconnected');
+    }
+    // ============================================================================
+    // Initialize
+    // ============================================================================
+    async initialize() {
+        this.setState('initializing');
+        const params = {
+            processId: null,
+            rootUri: this.config.rootUri,
+            capabilities: DEFAULT_CLIENT_CAPABILITIES,
+            workspaceFolders: [
+                {
+                    uri: this.config.rootUri,
+                    name: this.config.rootUri.split('/').pop() ?? 'workspace'
+                }
+            ]
+        };
+        const result = (await this.sendRequest('initialize', params));
+        this._capabilities = result.capabilities;
+        this.emitEvent('onServerCapabilities', result.capabilities);
+        // Send initialized notification
+        this.sendNotification('initialized', {});
+        this.setState('ready');
+        if (this.config.debug) {
+            console.log('[LSP] Initialized with capabilities:', result.capabilities);
+        }
+    }
+    // ============================================================================
+    // JSON-RPC Transport
+    // ============================================================================
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            if (this.config.debug) {
+                console.log('[LSP] Received:', message);
+            }
+            if ('id' in message && message.id !== null) {
+                // Response to a request
+                const pending = this.pendingRequests.get(message.id);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    this.pendingRequests.delete(message.id);
+                    if ('error' in message) {
+                        pending.reject(new Error(message.error.message));
+                    }
+                    else {
+                        pending.resolve(message.result);
+                    }
+                }
+            }
+            else if ('method' in message) {
+                // Server notification or request — dispatch to every subscriber.
+                const handlers = this.notificationHandlers.get(message.method);
+                if (handlers && handlers.size > 0) {
+                    // Iterate a copy so a handler can unsubscribe during dispatch.
+                    for (const handler of [...handlers]) {
+                        try {
+                            handler(message.params);
+                        }
+                        catch (err) {
+                            if (this.config.debug) {
+                                console.error(`[LSP] Notification handler for "${message.method}" threw:`, err);
+                            }
+                        }
+                    }
+                }
+                else if (this.config.debug) {
+                    console.log(`[LSP] Unhandled notification: ${message.method}`);
+                }
+            }
+        }
+        catch (err) {
+            if (this.config.debug) {
+                console.error('[LSP] Failed to parse message:', err);
+            }
+        }
+    }
+    async sendRequest(method, params) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('Not connected to LSP server');
+        }
+        const id = ++this.requestId;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request ${method} timed out`));
+            }, this.config.requestTimeout ?? 30000);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timeout
+            });
+            const request = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params
+            };
+            if (this.config.debug) {
+                console.log('[LSP] Sending:', request);
+            }
+            this.ws.send(JSON.stringify(request));
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params
+        };
+        if (this.config.debug) {
+            console.log('[LSP] Sending notification:', notification);
+        }
+        this.ws.send(JSON.stringify(notification));
+    }
+    onNotification(method, handler) {
+        let handlers = this.notificationHandlers.get(method);
+        if (!handlers) {
+            handlers = new Set();
+            this.notificationHandlers.set(method, handlers);
+        }
+        handlers.add(handler);
+        // Unsubscribe removes only this specific callback, leaving any other
+        // subscribers to the same method intact.
+        return () => {
+            const set = this.notificationHandlers.get(method);
+            if (!set)
+                return;
+            set.delete(handler);
+            if (set.size === 0) {
+                this.notificationHandlers.delete(method);
+            }
+        };
+    }
+    // ============================================================================
+    // Event Handlers
+    // ============================================================================
+    on(event, handler) {
+        let handlers = this.eventHandlers[event];
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers[event] = handlers;
+        }
+        handlers.add(handler);
+        // Unsubscribe removes only this specific callback, leaving any other
+        // subscribers to the same event intact.
+        return () => {
+            const set = this.eventHandlers[event];
+            if (!set)
+                return;
+            set.delete(handler);
+            if (set.size === 0) {
+                delete this.eventHandlers[event];
+            }
+        };
+    }
+    // ============================================================================
+    // Document Sync
+    // ============================================================================
+    didOpen(uri, languageId, version, text) {
+        this.openDocuments.set(uri, { version, languageId });
+        const params = {
+            uri,
+            languageId,
+            version,
+            text
+        };
+        this.sendNotification('textDocument/didOpen', { textDocument: params });
+    }
+    didChange(uri, version, changes) {
+        const doc = this.openDocuments.get(uri);
+        if (doc) {
+            doc.version = version;
+        }
+        this.sendNotification('textDocument/didChange', {
+            textDocument: { uri, version },
+            contentChanges: changes
+        });
+    }
+    didSave(uri, text) {
+        this.sendNotification('textDocument/didSave', {
+            textDocument: { uri },
+            text
+        });
+    }
+    didClose(uri) {
+        this.openDocuments.delete(uri);
+        this.diagnosticsCache.delete(uri);
+        this.sendNotification('textDocument/didClose', {
+            textDocument: { uri }
+        });
+    }
+    // ============================================================================
+    // Completion
+    // ============================================================================
+    async completion(uri, position, triggerKind = 1, triggerCharacter) {
+        if (!this._capabilities?.completionProvider) {
+            return [];
+        }
+        const params = {
+            textDocument: { uri },
+            position,
+            context: { triggerKind, triggerCharacter }
+        };
+        const result = await this.sendRequest('textDocument/completion', params);
+        if (!result)
+            return [];
+        if (Array.isArray(result))
+            return result;
+        return result.items;
+    }
+    async completionResolve(item) {
+        if (!this._capabilities?.completionProvider?.resolveProvider) {
+            return item;
+        }
+        return this.sendRequest('completionItem/resolve', item);
+    }
+    // ============================================================================
+    // Hover
+    // ============================================================================
+    async hover(uri, position) {
+        if (!this._capabilities?.hoverProvider) {
+            return null;
+        }
+        const params = {
+            textDocument: { uri },
+            position
+        };
+        return this.sendRequest('textDocument/hover', params);
+    }
+    // ============================================================================
+    // Signature Help
+    // ============================================================================
+    async signatureHelp(uri, position, triggerCharacter) {
+        if (!this._capabilities?.signatureHelpProvider) {
+            return null;
+        }
+        const params = {
+            textDocument: { uri },
+            position,
+            context: {
+                triggerKind: triggerCharacter ? 2 : 1,
+                triggerCharacter,
+                isRetrigger: false
+            }
+        };
+        return this.sendRequest('textDocument/signatureHelp', params);
+    }
+    // ============================================================================
+    // Go to Definition
+    // ============================================================================
+    async definition(uri, position) {
+        if (!this._capabilities?.definitionProvider) {
+            return [];
+        }
+        const params = {
+            textDocument: { uri },
+            position
+        };
+        const result = await this.sendRequest('textDocument/definition', params);
+        if (!result)
+            return [];
+        return Array.isArray(result) ? result : [result];
+    }
+    async typeDefinition(uri, position) {
+        if (!this._capabilities?.typeDefinitionProvider) {
+            return [];
+        }
+        const result = await this.sendRequest('textDocument/typeDefinition', { textDocument: { uri }, position });
+        if (!result)
+            return [];
+        return Array.isArray(result) ? result : [result];
+    }
+    // ============================================================================
+    // References
+    // ============================================================================
+    async references(uri, position, includeDeclaration = true) {
+        if (!this._capabilities?.referencesProvider) {
+            return [];
+        }
+        const params = {
+            textDocument: { uri },
+            position,
+            context: { includeDeclaration }
+        };
+        const result = await this.sendRequest('textDocument/references', params);
+        return result ?? [];
+    }
+    // ============================================================================
+    // Code Actions
+    // ============================================================================
+    async codeAction(uri, range, diagnostics = []) {
+        if (!this._capabilities?.codeActionProvider) {
+            return [];
+        }
+        const params = {
+            textDocument: { uri },
+            range,
+            context: { diagnostics }
+        };
+        const result = await this.sendRequest('textDocument/codeAction', params);
+        return result ?? [];
+    }
+    // ============================================================================
+    // Rename
+    // ============================================================================
+    async prepareRename(uri, position) {
+        const renameOptions = this._capabilities?.renameProvider;
+        if (!renameOptions || (typeof renameOptions === 'object' && !renameOptions.prepareProvider)) {
+            return null;
+        }
+        return this.sendRequest('textDocument/prepareRename', { textDocument: { uri }, position });
+    }
+    async rename(uri, position, newName) {
+        if (!this._capabilities?.renameProvider) {
+            return null;
+        }
+        const params = {
+            textDocument: { uri },
+            position,
+            newName
+        };
+        return this.sendRequest('textDocument/rename', params);
+    }
+    // ============================================================================
+    // Formatting
+    // ============================================================================
+    async formatting(uri, options) {
+        if (!this._capabilities?.documentFormattingProvider) {
+            return [];
+        }
+        const params = {
+            textDocument: { uri },
+            options: {
+                tabSize: options?.tabSize ?? 2,
+                insertSpaces: options?.insertSpaces ?? true,
+                trimTrailingWhitespace: options?.trimTrailingWhitespace,
+                insertFinalNewline: options?.insertFinalNewline,
+                trimFinalNewlines: options?.trimFinalNewlines
+            }
+        };
+        const result = await this.sendRequest('textDocument/formatting', params);
+        return result ?? [];
+    }
+    // ============================================================================
+    // Diagnostics
+    // ============================================================================
+    getDiagnostics(uri) {
+        return this.diagnosticsCache.get(uri) ?? [];
+    }
+    getAllDiagnostics() {
+        return new Map(this.diagnosticsCache);
+    }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
+    getCompletionTriggerCharacters() {
+        return this._capabilities?.completionProvider?.triggerCharacters ?? [];
+    }
+    getSignatureHelpTriggerCharacters() {
+        return this._capabilities?.signatureHelpProvider?.triggerCharacters ?? [];
+    }
+    supportsFeature(feature) {
+        if (!this._capabilities)
+            return false;
+        return !!this._capabilities[feature];
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createLSPClient(config) {
+    return new LSPClient(config);
+}
+// ============================================================================
+// Helper: Position Utilities
+// ============================================================================
+export function positionToOffset(content, position) {
+    const lines = content.split('\n');
+    let offset = 0;
+    for (let i = 0; i < position.line && i < lines.length; i++) {
+        offset += lines[i].length + 1; // +1 for newline
+    }
+    offset += Math.min(position.character, lines[position.line]?.length ?? 0);
+    return offset;
+}
+export function offsetToPosition(content, offset) {
+    const lines = content.split('\n');
+    let remaining = offset;
+    for (let line = 0; line < lines.length; line++) {
+        if (remaining <= lines[line].length) {
+            return { line, character: remaining };
+        }
+        remaining -= lines[line].length + 1;
+    }
+    // Past end of document
+    return {
+        line: lines.length - 1,
+        character: lines[lines.length - 1]?.length ?? 0
+    };
+}
+export function rangeToOffsets(content, range) {
+    return {
+        start: positionToOffset(content, range.start),
+        end: positionToOffset(content, range.end)
+    };
+}

package/dist/services/mock-ai.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Mock AI Service for Demos
+ * Simulates AI responses with streaming and tool calls
+ */
+import type { AIMessage, AIToolCall } from '../types';
+export interface MockAIConfig {
+    streamingDelay?: number;
+    responseDelay?: number;
+    simulateErrors?: boolean;
+    errorRate?: number;
+}
+/**
+ * Simulate streaming response
+ */
+export declare function streamMockResponse(message: string, config?: MockAIConfig): AsyncGenerator<string, void, unknown>;
+/**
+ * Get mock response (non-streaming)
+ */
+export declare function getMockResponse(message: string, config?: MockAIConfig): Promise<{
+    content: string;
+    toolCalls?: AIToolCall[];
+}>;
+/**
+ * Execute mock tool call
+ */
+export declare function executeMockToolCall(toolCall: AIToolCall, config?: MockAIConfig): Promise<{
+    result: unknown;
+    duration: number;
+}>;
+/**
+ * Create a mock AI message with metadata
+ */
+export declare function createMockMessage(role: 'user' | 'assistant', content: string, options?: Partial<AIMessage>): AIMessage;
+/**
+ * Generate a conversation with mock messages
+ */
+export declare function generateMockConversation(turns?: number): AIMessage[];