@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/conflict-predictor.js

@@ -0,0 +1,316 @@
+/**
+ * Conflict Predictor
+ *
+ * Real-time conflict prediction for collaborative editing.
+ * Detects when multiple users are editing the same semantic region
+ * and predicts potential merge conflicts before they happen.
+ */
+const DEFAULT_CONFIG = {
+    recentEditWindow: 30000,
+    proximityThreshold: 10,
+    warningThreshold: 0.3,
+    includeAI: true
+};
+/**
+ * Conflict Predictor class
+ */
+export class ConflictPredictor {
+    config;
+    listeners = new Set();
+    lastZones = [];
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Predict conflict zones based on user awareness and semantic regions
+     */
+    predict(users, semanticRegions) {
+        const zones = [];
+        const now = Date.now();
+        // Filter to active users (edited recently)
+        const activeUsers = users.filter((user) => {
+            if (!this.config.includeAI && user.isAI)
+                return false;
+            return now - user.lastEditTime < this.config.recentEditWindow;
+        });
+        // Need at least 2 active users for conflict
+        if (activeUsers.length < 2) {
+            this.lastZones = [];
+            this.notifyListeners([]);
+            return [];
+        }
+        // Check each semantic region for multiple users
+        for (const region of semanticRegions) {
+            const usersInRegion = activeUsers.filter((user) => user.cursorLine >= region.startLine &&
+                user.cursorLine <= region.endLine);
+            // Also check for users near the region
+            const usersNearRegion = activeUsers.filter((user) => {
+                const distanceToRegion = Math.min(Math.abs(user.cursorLine - region.startLine), Math.abs(user.cursorLine - region.endLine));
+                return (distanceToRegion <= this.config.proximityThreshold &&
+                    !usersInRegion.includes(user));
+            });
+            const allRelevantUsers = [...usersInRegion, ...usersNearRegion];
+            if (allRelevantUsers.length >= 2) {
+                const probability = this.calculateProbability(allRelevantUsers, region, now);
+                if (probability >= this.config.warningThreshold) {
+                    zones.push({
+                        id: `conflict-${region.startLine}-${region.endLine}`,
+                        startLine: region.startLine,
+                        endLine: region.endLine,
+                        probability,
+                        severity: this.getSeverity(probability),
+                        participants: allRelevantUsers.map((user) => ({
+                            userId: user.id,
+                            userName: user.name,
+                            color: user.color,
+                            cursorLine: user.cursorLine,
+                            lastEditTime: user.lastEditTime,
+                            isAI: user.isAI
+                        })),
+                        semanticUnit: region.label || `Lines ${region.startLine + 1}-${region.endLine + 1}`,
+                        suggestion: this.getSuggestion(allRelevantUsers, probability)
+                    });
+                }
+            }
+        }
+        // Also check for proximity-based conflicts outside semantic regions
+        const proximityZones = this.detectProximityConflicts(activeUsers, semanticRegions);
+        zones.push(...proximityZones);
+        // Merge overlapping zones
+        const mergedZones = this.mergeOverlappingZones(zones);
+        this.lastZones = mergedZones;
+        this.notifyListeners(mergedZones);
+        return mergedZones;
+    }
+    /**
+     * Get the last predicted zones
+     */
+    getLastZones() {
+        return this.lastZones;
+    }
+    /**
+     * Subscribe to conflict zone changes
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * Calculate conflict probability
+     */
+    calculateProbability(users, region, now) {
+        // Factors:
+        // 1. Number of users (more users = higher probability)
+        // 2. Cursor proximity (closer = higher probability)
+        // 3. Edit recency (more recent = higher probability)
+        // 4. Region size (smaller = higher probability due to less space)
+        const userCount = users.length;
+        const userCountFactor = Math.min(1, (userCount - 1) / 3); // 2 users = 0.33, 3 = 0.66, 4+ = 1
+        // Calculate average cursor proximity
+        const cursorLines = users.map((u) => u.cursorLine);
+        const avgProximity = this.calculateAverageProximity(cursorLines);
+        const proximityFactor = Math.max(0, 1 - avgProximity / this.config.proximityThreshold);
+        // Calculate edit recency factor
+        const recencyFactors = users.map((u) => {
+            const timeSinceEdit = now - u.lastEditTime;
+            return Math.max(0, 1 - timeSinceEdit / this.config.recentEditWindow);
+        });
+        const avgRecency = recencyFactors.reduce((a, b) => a + b, 0) / recencyFactors.length;
+        // Region size factor (smaller regions are more conflict-prone)
+        const regionSize = region.endLine - region.startLine + 1;
+        const sizeFactor = Math.min(1, 10 / regionSize);
+        // Weighted combination
+        const probability = userCountFactor * 0.3 + proximityFactor * 0.35 + avgRecency * 0.25 + sizeFactor * 0.1;
+        return Math.min(1, Math.max(0, probability));
+    }
+    /**
+     * Calculate average pairwise proximity between cursor positions
+     */
+    calculateAverageProximity(lines) {
+        if (lines.length < 2)
+            return Infinity;
+        let totalDistance = 0;
+        let pairs = 0;
+        for (let i = 0; i < lines.length; i++) {
+            for (let j = i + 1; j < lines.length; j++) {
+                totalDistance += Math.abs(lines[i] - lines[j]);
+                pairs++;
+            }
+        }
+        return pairs > 0 ? totalDistance / pairs : Infinity;
+    }
+    /**
+     * Get severity level from probability
+     */
+    getSeverity(probability) {
+        if (probability >= 0.8)
+            return 'critical';
+        if (probability >= 0.6)
+            return 'high';
+        if (probability >= 0.4)
+            return 'medium';
+        return 'low';
+    }
+    /**
+     * Get suggestion based on conflict state
+     */
+    getSuggestion(users, probability) {
+        const userNames = users.map((u) => u.name);
+        const aiUsers = users.filter((u) => u.isAI);
+        const humanUsers = users.filter((u) => !u.isAI);
+        if (probability >= 0.8) {
+            if (aiUsers.length > 0 && humanUsers.length > 0) {
+                return `AI is editing nearby. Consider pausing AI changes.`;
+            }
+            return `High conflict risk with ${userNames.join(', ')}. Consider coordinating.`;
+        }
+        if (probability >= 0.6) {
+            return `${userNames.join(' and ')} are editing nearby.`;
+        }
+        return `Multiple editors in this area.`;
+    }
+    /**
+     * Detect proximity-based conflicts outside semantic regions
+     */
+    detectProximityConflicts(users, semanticRegions) {
+        const zones = [];
+        // Group users by proximity
+        const visited = new Set();
+        for (let i = 0; i < users.length; i++) {
+            if (visited.has(users[i].id))
+                continue;
+            const cluster = [users[i]];
+            visited.add(users[i].id);
+            for (let j = i + 1; j < users.length; j++) {
+                if (visited.has(users[j].id))
+                    continue;
+                const distance = Math.abs(users[i].cursorLine - users[j].cursorLine);
+                if (distance <= this.config.proximityThreshold) {
+                    cluster.push(users[j]);
+                    visited.add(users[j].id);
+                }
+            }
+            if (cluster.length >= 2) {
+                // Check if this cluster is already covered by a semantic region
+                const minLine = Math.min(...cluster.map((u) => u.cursorLine));
+                const maxLine = Math.max(...cluster.map((u) => u.cursorLine));
+                const isInSemanticRegion = semanticRegions.some((r) => minLine >= r.startLine && maxLine <= r.endLine);
+                if (!isInSemanticRegion) {
+                    const probability = this.calculateProximityProbability(cluster);
+                    if (probability >= this.config.warningThreshold) {
+                        zones.push({
+                            id: `proximity-${minLine}-${maxLine}`,
+                            startLine: Math.max(0, minLine - 2),
+                            endLine: maxLine + 2,
+                            probability,
+                            severity: this.getSeverity(probability),
+                            participants: cluster.map((user) => ({
+                                userId: user.id,
+                                userName: user.name,
+                                color: user.color,
+                                cursorLine: user.cursorLine,
+                                lastEditTime: user.lastEditTime,
+                                isAI: user.isAI
+                            })),
+                            semanticUnit: `Lines ${minLine + 1}-${maxLine + 1}`,
+                            suggestion: this.getSuggestion(cluster, probability)
+                        });
+                    }
+                }
+            }
+        }
+        return zones;
+    }
+    /**
+     * Calculate probability for proximity-based conflict
+     */
+    calculateProximityProbability(users) {
+        const now = Date.now();
+        // Simpler calculation for proximity conflicts
+        const cursorLines = users.map((u) => u.cursorLine);
+        const avgProximity = this.calculateAverageProximity(cursorLines);
+        const proximityFactor = Math.max(0, 1 - avgProximity / this.config.proximityThreshold);
+        const recencyFactors = users.map((u) => {
+            const timeSinceEdit = now - u.lastEditTime;
+            return Math.max(0, 1 - timeSinceEdit / this.config.recentEditWindow);
+        });
+        const avgRecency = recencyFactors.reduce((a, b) => a + b, 0) / recencyFactors.length;
+        return proximityFactor * 0.6 + avgRecency * 0.4;
+    }
+    /**
+     * Merge overlapping conflict zones
+     */
+    mergeOverlappingZones(zones) {
+        if (zones.length <= 1)
+            return zones;
+        // Sort by start line
+        const sorted = [...zones].sort((a, b) => a.startLine - b.startLine);
+        const merged = [];
+        let current = sorted[0];
+        for (let i = 1; i < sorted.length; i++) {
+            const next = sorted[i];
+            if (next.startLine <= current.endLine + 1) {
+                // Merge overlapping zones
+                current = {
+                    ...current,
+                    id: `${current.id}-${next.id}`,
+                    endLine: Math.max(current.endLine, next.endLine),
+                    probability: Math.max(current.probability, next.probability),
+                    severity: this.getSeverity(Math.max(current.probability, next.probability)),
+                    participants: this.mergeParticipants(current.participants, next.participants),
+                    semanticUnit: current.semanticUnit
+                };
+            }
+            else {
+                merged.push(current);
+                current = next;
+            }
+        }
+        merged.push(current);
+        return merged;
+    }
+    /**
+     * Merge participant lists, removing duplicates
+     */
+    mergeParticipants(a, b) {
+        const seen = new Set();
+        const result = [];
+        for (const p of [...a, ...b]) {
+            if (!seen.has(p.userId)) {
+                seen.add(p.userId);
+                result.push(p);
+            }
+        }
+        return result;
+    }
+    /**
+     * Notify listeners of zone changes
+     */
+    notifyListeners(zones) {
+        for (const listener of this.listeners) {
+            try {
+                listener(zones);
+            }
+            catch (e) {
+                console.error('[ConflictPredictor] Listener error:', e);
+            }
+        }
+    }
+}
+/**
+ * Create a conflict predictor instance
+ */
+export function createConflictPredictor(config) {
+    return new ConflictPredictor(config);
+}
+// Singleton instance
+let globalPredictor = null;
+/**
+ * Get the global conflict predictor
+ */
+export function getConflictPredictor() {
+    if (!globalPredictor) {
+        globalPredictor = createConflictPredictor();
+    }
+    return globalPredictor;
+}

package/dist/components/editor/core/crdt-binding.d.ts

@@ -0,0 +1,118 @@
+/**
+ * CRDT binding for the custom editor
+ *
+ * This module provides integration between the custom editor state
+ * and Yjs CRDT for real-time collaborative editing.
+ */
+import * as Y from 'yjs';
+import type { EditorState, Position } from './state';
+/**
+ * CRDT binding configuration
+ */
+export interface CRDTBindingConfig {
+    /** Yjs document */
+    doc: Y.Doc;
+    /** Text type name in the document */
+    textName?: string;
+    /** Editor state to bind */
+    editorState: EditorState;
+}
+/**
+ * Position in both local and CRDT coordinates
+ */
+export interface CRDTPosition {
+    /** Local position (line/column) */
+    local: Position;
+    /** CRDT index position */
+    index: number;
+}
+/**
+ * CRDT binding class that syncs editor state with Yjs
+ */
+export declare class CRDTBinding {
+    private doc;
+    private text;
+    private editorState;
+    private isUpdating;
+    private isDestroyed;
+    private cleanupFns;
+    private textObserver;
+    constructor(config: CRDTBindingConfig);
+    /**
+     * Set up bidirectional bindings
+     */
+    private setupBindings;
+    /**
+     * Sync content from CRDT to editor
+     */
+    private syncFromCRDT;
+    /**
+     * Handle changes from CRDT
+     * Uses Yjs relative positions for accurate cursor preservation during concurrent edits
+     */
+    private handleCRDTChange;
+    /**
+     * Convert position to index using provided lines (for atomic operations)
+     */
+    private positionToIndexWithLines;
+    /**
+     * Handle local editor changes
+     */
+    private handleLocalChange;
+    /**
+     * Convert editor position to CRDT index
+     */
+    positionToIndex(position: Position): number;
+    /**
+     * Convert CRDT index to editor position
+     */
+    indexToPosition(index: number): Position;
+    /**
+     * Apply a full local content replacement into the bound editor state,
+     * which propagates to the CRDT / Yjs text via the local-change listener.
+     *
+     * Use this for edits that originate outside the bound EditorState (e.g. an
+     * inner editor component that maintains its own state) so that local typing
+     * reaches collaborators. No-op while a remote update is being applied, which
+     * also prevents a remote -> local -> remote echo loop.
+     *
+     * @returns `true` if the content changed and was propagated, `false` otherwise.
+     */
+    setContent(content: string): boolean;
+    /**
+     * Whether a remote (CRDT-originated) update is currently being applied.
+     * Callers can use this to suppress re-sending an echoed local change.
+     */
+    get isApplyingRemoteChange(): boolean;
+    /**
+     * Get the Yjs text type
+     */
+    getText(): Y.Text;
+    /**
+     * Get the Yjs document
+     */
+    getDoc(): Y.Doc;
+    /**
+     * Clean up bindings
+     */
+    destroy(): void;
+}
+/**
+ * Create a CRDT binding
+ */
+export declare function createCRDTBinding(config: CRDTBindingConfig): CRDTBinding;
+/**
+ * Relative position for cursor synchronization
+ */
+export interface RelativePosition {
+    /** Yjs relative position */
+    yRelPos: Y.RelativePosition;
+}
+/**
+ * Create a relative position from an editor position
+ */
+export declare function createRelativePosition(text: Y.Text, binding: CRDTBinding, position: Position): RelativePosition;
+/**
+ * Resolve a relative position to an editor position
+ */
+export declare function resolveRelativePosition(doc: Y.Doc, binding: CRDTBinding, relPos: RelativePosition): Position | null;