@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/services/ide-integration.js

@@ -0,0 +1,367 @@
+/**
+ * IDE Integration Service
+ *
+ * Coordinates VFS, Agents, and Collaboration stores into a unified system.
+ * Handles cross-store communication and event routing.
+ */
+import * as vfsStore from '../stores/vfs.svelte';
+import * as agentsStore from '../stores/agents.svelte';
+import * as collabStore from '../stores/collaboration.svelte';
+// ============================================================================
+// State
+// ============================================================================
+let config = null;
+let subscriptions = [];
+let initialized = false;
+// ============================================================================
+// Initialization
+// ============================================================================
+/**
+ * Initialize the IDE integration layer
+ * Connects all stores and sets up event routing
+ */
+export function initialize(integrationConfig) {
+    if (initialized) {
+        cleanup();
+    }
+    config = integrationConfig;
+    // Initialize VFS store
+    vfsStore.initialize(config.userId, config.workspaceId);
+    // Initialize collaboration if enabled
+    if (config.enableCollaboration !== false) {
+        const collabUser = {
+            id: config.userId,
+            name: config.userName,
+            isAI: false,
+            color: 'var(--ide-collab-cursor-1)'
+        };
+        collabStore.initialize({
+            user: collabUser,
+            roomId: config.workspaceId,
+            serverUrl: config.vfsEndpoint ?? '/api/collab'
+        });
+    }
+    // Set up event routing
+    setupEventRouting();
+    initialized = true;
+}
+/**
+ * Set up cross-store event routing
+ */
+function setupEventRouting() {
+    // Route VFS events to agents store
+    const vfsUnsub = vfsStore.onEvent('*', (event) => {
+        handleVFSEvent(event);
+    });
+    subscriptions.push(vfsUnsub);
+    // Route team events to collaboration
+    const teamUnsub = agentsStore.onTeamEvent('*', (event) => {
+        handleTeamEvent(event);
+    });
+    subscriptions.push(teamUnsub);
+    // Route collaboration events to agents
+    const collabUnsub = collabStore.onEvent((event) => {
+        handleCollabEvent(event);
+    });
+    subscriptions.push(collabUnsub);
+}
+// ============================================================================
+// Event Handlers
+// ============================================================================
+/**
+ * Handle VFS events and route to appropriate stores
+ */
+function handleVFSEvent(event) {
+    // Forward agent-related events to agents store
+    agentsStore.handleVFSEvent(event);
+    switch (event.type) {
+        case 'update': {
+            const updateEvent = event;
+            // If update is from an agent, create team event
+            if (updateEvent.actorType === 'agent') {
+                const agent = agentsStore.getAgent(updateEvent.actor);
+                if (agent) {
+                    const operation = updateEvent.operation;
+                    const operationPath = operation.type === 'rename' ? operation.newPath : operation.path;
+                    agentsStore.addEvent({
+                        id: crypto.randomUUID(),
+                        timestamp: updateEvent.timestamp,
+                        workspaceId: event.workspaceId,
+                        agentId: updateEvent.actor,
+                        agent,
+                        type: 'file_modified',
+                        path: operationPath,
+                        operation: operation.type,
+                        lockAcquired: vfsStore.isLockedByMe(operationPath)
+                    });
+                }
+            }
+            break;
+        }
+        case 'lock_acquired': {
+            const lockEvent = event;
+            // If lock acquired by agent, update agent status
+            if (lockEvent.lock.holderType === 'agent') {
+                agentsStore.setAgentStatus(lockEvent.lock.holder, 'busy');
+            }
+            break;
+        }
+        case 'lock_released': {
+            const releaseEvent = event;
+            // Check if agent should return to online status
+            const agent = agentsStore.getAgent(releaseEvent.holder);
+            if (agent && agent.status === 'busy' && !agent.currentTask) {
+                agentsStore.setAgentStatus(releaseEvent.holder, 'online');
+            }
+            break;
+        }
+    }
+}
+/**
+ * Handle team events and route to collaboration
+ */
+function handleTeamEvent(event) {
+    if (!config?.enableCollaboration)
+        return;
+    switch (event.type) {
+        case 'agent_joined': {
+            // Add agent as collaboration user
+            const collabUser = {
+                id: event.agent.id,
+                name: event.agent.name,
+                isAI: true,
+                color: event.agent.color ?? 'var(--ide-collab-ai)'
+            };
+            collabStore.addUser(collabUser);
+            break;
+        }
+        case 'agent_left': {
+            collabStore.removeUser(event.agentId);
+            break;
+        }
+        case 'work_started': {
+            // Start AI collaboration session
+            const aiUser = {
+                id: event.agent.id,
+                name: event.agent.name,
+                isAI: true,
+                color: event.agent.color ?? 'var(--ide-collab-ai)'
+            };
+            const sessionId = collabStore.startAISession(config.workspaceId, aiUser);
+            collabStore.setAITask(sessionId, event.task.description);
+            break;
+        }
+        case 'task_completed': {
+            // Find and complete the AI session
+            const sessions = collabStore.getAISessions();
+            const session = sessions.find((s) => s.aiUser.id === event.agentId && s.status === 'active');
+            if (session) {
+                collabStore.completeAISession(session.id);
+            }
+            break;
+        }
+    }
+}
+/**
+ * Handle collaboration events
+ */
+function handleCollabEvent(event) {
+    // Map collaboration events back to agent store if needed
+    switch (event.type) {
+        case 'user_joined': {
+            const user = event.user;
+            if (user.isAI) {
+                // An AI joined via collaboration - register as agent
+                const existingAgent = agentsStore.getAgent(user.id);
+                if (!existingAgent) {
+                    agentsStore.addAgent({
+                        id: user.id,
+                        name: user.name,
+                        type: 'coder',
+                        status: 'online',
+                        capabilities: ['code_generation'],
+                        workspaceId: config?.workspaceId ?? '',
+                        joinedAt: new Date().toISOString(),
+                        lastActivity: new Date().toISOString(),
+                        color: user.color
+                    });
+                }
+            }
+            break;
+        }
+        case 'user_left': {
+            const userId = event.userId;
+            const agent = agentsStore.getAgent(userId);
+            if (agent) {
+                agentsStore.removeAgent(userId);
+            }
+            break;
+        }
+        case 'cursor_moved': {
+            // Convert collaboration cursor to agent cursor if from AI
+            const cursor = event.cursor;
+            const user = collabStore.getUsers().find((u) => u.id === cursor.userId);
+            if (user?.isAI) {
+                const agent = agentsStore.getAgent(cursor.userId);
+                if (agent) {
+                    agentsStore.updateCursor({
+                        agentId: cursor.userId,
+                        agent,
+                        filePath: config?.workspaceId ?? '', // Would need actual file path
+                        position: cursor.position,
+                        lastUpdate: new Date().toISOString()
+                    });
+                }
+            }
+            break;
+        }
+    }
+}
+// ============================================================================
+// Agent Cursor Sync
+// ============================================================================
+/**
+ * Update agent cursor position (called from editor)
+ */
+export function updateAgentCursorPosition(agentId, filePath, position, selection) {
+    const agent = agentsStore.getAgent(agentId);
+    if (!agent)
+        return;
+    const cursor = {
+        agentId,
+        agent,
+        filePath,
+        position,
+        selection,
+        lastUpdate: new Date().toISOString()
+    };
+    agentsStore.updateCursor(cursor);
+    // Also update collaboration cursors
+    if (config?.enableCollaboration) {
+        collabStore.updateCursor({
+            userId: agentId,
+            user: {
+                id: agent.id,
+                name: agent.name,
+                isAI: true,
+                color: agent.color ?? 'var(--ide-collab-ai)'
+            },
+            position,
+            selection: selection
+                ? {
+                    anchor: selection.start,
+                    head: selection.end
+                }
+                : undefined,
+            lastActivity: new Date()
+        });
+    }
+}
+// ============================================================================
+// Lock Coordination
+// ============================================================================
+/**
+ * Acquire lock with agent awareness
+ */
+export async function acquireLockWithContext(filePath, purpose) {
+    const lock = await vfsStore.acquireLock(filePath, purpose);
+    if (lock) {
+        // Notify collaboration that we're editing this file
+        if (config?.enableCollaboration) {
+            collabStore.setLocalAwareness({
+                editingFile: filePath,
+                state: 'active'
+            });
+        }
+    }
+    return lock;
+}
+/**
+ * Release lock with cleanup
+ */
+export async function releaseLockWithContext(filePath) {
+    await vfsStore.releaseLock(filePath);
+    // Update awareness
+    if (config?.enableCollaboration) {
+        collabStore.setLocalAwareness({
+            editingFile: undefined,
+            state: 'idle'
+        });
+    }
+}
+/**
+ * Check if file can be edited (not locked by others)
+ */
+export function canEditFile(filePath) {
+    const lockStatus = vfsStore.getLockStatus(filePath);
+    if (lockStatus.status === 'unlocked')
+        return true;
+    if (lockStatus.status === 'locked') {
+        return lockStatus.lock.holder === config?.userId;
+    }
+    return false;
+}
+/**
+ * Get agents currently editing a file
+ */
+export function getFileEditors(filePath) {
+    return agentsStore.getAgentsWorkingOnFile(filePath);
+}
+// ============================================================================
+// Context Getters
+// ============================================================================
+/**
+ * Get current IDE context
+ */
+export function getContext() {
+    if (!config)
+        return null;
+    return {
+        workspaceId: config.workspaceId,
+        userId: config.userId,
+        userName: config.userName,
+        connected: vfsStore.getConnected() && collabStore.getIsConnected(),
+        synced: collabStore.getSynced()
+    };
+}
+/**
+ * Get all online agents
+ */
+export function getOnlineAgents() {
+    return agentsStore.getOnlineAgents();
+}
+/**
+ * Get all locks
+ */
+export function getAllLocks() {
+    return vfsStore.getLocks();
+}
+/**
+ * Get lock for specific file
+ */
+export function getFileLock(filePath) {
+    return vfsStore.getLock(filePath);
+}
+// ============================================================================
+// Cleanup
+// ============================================================================
+/**
+ * Cleanup all subscriptions and reset state
+ */
+export function cleanup() {
+    // Unsubscribe all
+    subscriptions.forEach((unsub) => unsub());
+    subscriptions = [];
+    // Reset stores
+    vfsStore.reset();
+    agentsStore.reset();
+    collabStore.reset();
+    config = null;
+    initialized = false;
+}
+/**
+ * Check if integration is initialized
+ */
+export function isInitialized() {
+    return initialized;
+}

package/dist/services/lsp-client.d.ts

@@ -0,0 +1,69 @@
+/**
+ * LSP WebSocket Client
+ * Communicates with a language server via WebSocket + JSON-RPC
+ */
+import type { LSPClientConfig, LSPConnectionState, LSPClientEvents, ServerCapabilities, Position, Range, TextDocumentContentChangeEvent, CompletionItem, CompletionTriggerKind, Hover, SignatureHelp, Location, CodeAction, WorkspaceEdit, FormattingOptions, TextEdit, Diagnostic } from '../types/lsp';
+export declare class LSPClient {
+    private config;
+    private ws;
+    private requestId;
+    private pendingRequests;
+    private notificationHandlers;
+    private _state;
+    private _capabilities;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private openDocuments;
+    private diagnosticsCache;
+    private eventHandlers;
+    constructor(config: LSPClientConfig);
+    get state(): LSPConnectionState;
+    get capabilities(): ServerCapabilities | null;
+    get isReady(): boolean;
+    /**
+     * 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.
+     */
+    private emitEvent;
+    private setState;
+    connect(): Promise<void>;
+    private handleDisconnect;
+    disconnect(): Promise<void>;
+    private initialize;
+    private handleMessage;
+    private sendRequest;
+    private sendNotification;
+    onNotification(method: string, handler: (params: unknown) => void): () => void;
+    on<K extends keyof LSPClientEvents>(event: K, handler: LSPClientEvents[K]): () => void;
+    didOpen(uri: string, languageId: string, version: number, text: string): void;
+    didChange(uri: string, version: number, changes: TextDocumentContentChangeEvent[]): void;
+    didSave(uri: string, text?: string): void;
+    didClose(uri: string): void;
+    completion(uri: string, position: Position, triggerKind?: CompletionTriggerKind, triggerCharacter?: string): Promise<CompletionItem[]>;
+    completionResolve(item: CompletionItem): Promise<CompletionItem>;
+    hover(uri: string, position: Position): Promise<Hover | null>;
+    signatureHelp(uri: string, position: Position, triggerCharacter?: string): Promise<SignatureHelp | null>;
+    definition(uri: string, position: Position): Promise<Location[]>;
+    typeDefinition(uri: string, position: Position): Promise<Location[]>;
+    references(uri: string, position: Position, includeDeclaration?: boolean): Promise<Location[]>;
+    codeAction(uri: string, range: Range, diagnostics?: Diagnostic[]): Promise<CodeAction[]>;
+    prepareRename(uri: string, position: Position): Promise<Range | {
+        range: Range;
+        placeholder: string;
+    } | null>;
+    rename(uri: string, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+    formatting(uri: string, options?: Partial<FormattingOptions>): Promise<TextEdit[]>;
+    getDiagnostics(uri: string): Diagnostic[];
+    getAllDiagnostics(): Map<string, Diagnostic[]>;
+    getCompletionTriggerCharacters(): string[];
+    getSignatureHelpTriggerCharacters(): string[];
+    supportsFeature(feature: keyof ServerCapabilities): boolean;
+}
+export declare function createLSPClient(config: LSPClientConfig): LSPClient;
+export declare function positionToOffset(content: string, position: Position): number;
+export declare function offsetToPosition(content: string, offset: number): Position;
+export declare function rangeToOffsets(content: string, range: Range): {
+    start: number;
+    end: number;
+};