@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/complexity-analyzer.js

@@ -0,0 +1,376 @@
+/**
+ * Cognitive Complexity Analyzer
+ *
+ * Analyzes code complexity in real-time to help developers understand
+ * cognitive load and identify areas that may benefit from refactoring.
+ *
+ * Based on cognitive complexity research and common code quality metrics.
+ */
+/**
+ * Thresholds for complexity levels
+ */
+const THRESHOLDS = {
+    low: 30,
+    medium: 50,
+    high: 70,
+    critical: 85,
+};
+/**
+ * Weights for different complexity factors
+ */
+const WEIGHTS = {
+    nestingDepth: 15,
+    branchingFactor: 8,
+    lineCount: 0.3,
+    identifierCount: 0.2,
+    callCount: 0.5,
+};
+/**
+ * Patterns for detecting code constructs
+ */
+const PATTERNS = {
+    // Nesting increasers
+    nestingStart: /\b(if|for|while|switch|try|catch|with)\s*\(|=>\s*\{|\bdo\s*\{/,
+    // Branching statements
+    branching: /\b(if|else\s+if|else|case|default|\?.*:)/g,
+    // Function definitions — exclude control flow keywords from method-style match
+    functionDef: /\b(function\s+(\w+)|(\w+)\s*=\s*(?:async\s*)?\(|(?!(?:if|else|for|while|do|switch|try|catch|finally|with|return|throw|new|typeof|void|delete|await|yield)\b)(\w+)\s*\([^)]*\)\s*\{|class\s+(\w+))/,
+    // Function calls
+    functionCall: /\b\w+\s*\(/g,
+    // Identifiers (simplified)
+    identifier: /\b[a-zA-Z_]\w*\b/g,
+    // Block openers
+    blockOpen: /\{/g,
+    // Block closers
+    blockClose: /\}/g,
+};
+/**
+ * Complexity Analyzer class
+ */
+export class ComplexityAnalyzer {
+    cache = new Map();
+    cacheKey = '';
+    /**
+     * Analyze complexity of the given lines
+     */
+    analyze(lines, language = 'javascript') {
+        // Simple cache check based on content hash
+        const key = this.computeCacheKey(lines);
+        if (key === this.cacheKey && this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const regions = this.identifyRegions(lines, language);
+        const analyzedRegions = regions.map((region) => this.analyzeRegion(lines, region));
+        const hotspots = this.findHotspots(analyzedRegions);
+        const overall = this.calculateOverall(analyzedRegions, lines.length);
+        const metrics = {
+            overall,
+            level: this.getLevel(overall),
+            regions: analyzedRegions,
+            hotspots,
+        };
+        this.cacheKey = key;
+        this.cache.set(key, metrics);
+        return metrics;
+    }
+    /**
+     * Get complexity for a specific line
+     */
+    getLineComplexity(metrics, line) {
+        for (const region of metrics.regions) {
+            if (line >= region.startLine && line <= region.endLine) {
+                return region.score;
+            }
+        }
+        return 0;
+    }
+    /**
+     * Check if a line is a hotspot
+     */
+    isHotspot(metrics, line) {
+        return metrics.hotspots.includes(line);
+    }
+    /**
+     * Compute a cache key from all line content using a fast hash
+     */
+    computeCacheKey(lines) {
+        // Use a simple DJB2 hash across all line content for reliable cache invalidation
+        let hash = 5381;
+        for (let i = 0; i < lines.length; i++) {
+            const text = lines[i].text;
+            for (let j = 0; j < text.length; j++) {
+                hash = ((hash << 5) + hash + text.charCodeAt(j)) | 0;
+            }
+            // Include newline separator in hash
+            hash = ((hash << 5) + hash + 10) | 0;
+        }
+        return `${lines.length}:${hash}`;
+    }
+    /**
+     * Identify code regions (functions, classes, blocks)
+     *
+     * Uses brace-depth tracking to correctly handle inline braces
+     * (object literals, destructuring) that don't represent new blocks.
+     */
+    identifyRegions(lines, _language) {
+        const regions = [];
+        // Track blocks with their brace depth at push time
+        const blockStack = [];
+        let braceDepth = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const text = lines[i].text;
+            // Check for function/class definition
+            const funcMatch = text.match(PATTERNS.functionDef);
+            // Process character by character to properly match braces
+            // Skip braces inside strings and comments
+            let inString = null;
+            let inLineComment = false;
+            for (let ch = 0; ch < text.length; ch++) {
+                const c = text[ch];
+                const next = text[ch + 1];
+                // Handle line comments
+                if (!inString && c === '/' && next === '/') {
+                    inLineComment = true;
+                    break;
+                }
+                // Handle strings
+                if (!inLineComment) {
+                    if (inString) {
+                        if (c === inString && text[ch - 1] !== '\\') {
+                            inString = null;
+                        }
+                        continue;
+                    }
+                    else if (c === '"' || c === "'" || c === '`') {
+                        inString = c;
+                        continue;
+                    }
+                }
+                if (!inString && !inLineComment) {
+                    if (c === '{') {
+                        braceDepth++;
+                        // If this is the opening brace of a function/class def, push it
+                        if (funcMatch && this.isDefOpeningBrace(text, ch, funcMatch)) {
+                            blockStack.push({ line: i, type: funcMatch[5] ? 'class' : 'function', name: funcMatch[2] || funcMatch[3] || funcMatch[4] || funcMatch[5], depth: braceDepth });
+                        }
+                        else if (!funcMatch || braceDepth > (blockStack.length > 0 ? blockStack[blockStack.length - 1].depth : 0) + 1) {
+                            // Anonymous/inline brace — only push as block if it's a
+                            // statement-level block (i.e., after control flow keyword on this line)
+                            const prefix = text.slice(0, ch).trim();
+                            if (/\b(if|else|for|while|do|switch|try|catch|finally)\b/.test(prefix) || prefix.endsWith('=>') || prefix.endsWith(')')) {
+                                blockStack.push({ line: i, type: 'block', depth: braceDepth });
+                            }
+                            // Otherwise it's an expression brace (object literal, destructuring) — ignore
+                        }
+                    }
+                    else if (c === '}') {
+                        // Close: pop if this brace matches a tracked block's depth
+                        if (blockStack.length > 0 && braceDepth === blockStack[blockStack.length - 1].depth) {
+                            const block = blockStack.pop();
+                            if (block.type === 'function' || block.type === 'class') {
+                                regions.push({
+                                    startLine: block.line,
+                                    endLine: i,
+                                    type: block.type,
+                                    name: block.name,
+                                });
+                            }
+                        }
+                        braceDepth = Math.max(0, braceDepth - 1);
+                    }
+                }
+            }
+        }
+        // If no regions found, treat whole file as one region
+        if (regions.length === 0 && lines.length > 0) {
+            regions.push({
+                startLine: 0,
+                endLine: lines.length - 1,
+                type: 'file',
+            });
+        }
+        return regions;
+    }
+    /**
+     * Check if a `{` at position `ch` is the opening brace of a function/class definition
+     */
+    isDefOpeningBrace(text, ch, funcMatch) {
+        // For class: `class Foo {` — the `{` follows the class name
+        if (funcMatch[5]) {
+            return true; // First `{` on a class line is the class body
+        }
+        // For functions: the `{` should follow the parameter list closing `)`
+        // or follow `=>` for arrow functions
+        const before = text.slice(0, ch).trimEnd();
+        return before.endsWith(')') || before.endsWith('=>');
+    }
+    /**
+     * Analyze a specific region
+     */
+    analyzeRegion(lines, region) {
+        const factors = this.calculateFactors(lines, region.startLine, region.endLine);
+        const score = this.calculateScore(factors);
+        const suggestion = this.getSuggestion(factors, score);
+        return {
+            ...region,
+            score,
+            factors,
+            suggestion,
+        };
+    }
+    /**
+     * Calculate complexity factors for a range of lines
+     */
+    calculateFactors(lines, startLine, endLine) {
+        let nestingDepth = 0;
+        let maxNesting = 0;
+        let branchingFactor = 0;
+        let callCount = 0;
+        const identifiers = new Set();
+        // Use a global version of the nesting pattern so we can count all matches per line
+        const nestingStartGlobal = /\b(if|for|while|switch|try|catch|with)\s*\(|=>\s*\{|\bdo\s*\{/g;
+        // Keywords that should NOT be counted as function calls
+        const controlKeywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'function', 'return', 'typeof', 'new', 'throw', 'await', 'yield', 'import', 'export', 'class', 'super', 'this', 'void', 'delete', 'in', 'of']);
+        for (let i = startLine; i <= endLine && i < lines.length; i++) {
+            const text = lines[i].text;
+            // Track nesting — count ALL nesting openers per line
+            nestingStartGlobal.lastIndex = 0;
+            let nestingMatches = 0;
+            while (nestingStartGlobal.exec(text) !== null) {
+                nestingMatches++;
+            }
+            nestingDepth += nestingMatches;
+            maxNesting = Math.max(maxNesting, nestingDepth);
+            // Count closing braces (simplified nesting tracking)
+            const closes = (text.match(PATTERNS.blockClose) || []).length;
+            nestingDepth = Math.max(0, nestingDepth - closes);
+            // Count branching
+            const branches = text.match(PATTERNS.branching);
+            if (branches) {
+                branchingFactor += branches.length;
+            }
+            // Count function calls — exclude control keywords and function declaration names
+            const callRegex = /\b(\w+)\s*\(/g;
+            let callMatch;
+            while ((callMatch = callRegex.exec(text)) !== null) {
+                if (controlKeywords.has(callMatch[1]))
+                    continue;
+                // Skip function declaration names: "function foo(" → "foo" is not a call
+                const before = text.slice(0, callMatch.index).trimEnd();
+                if (before.endsWith('function'))
+                    continue;
+                callCount++;
+            }
+            // Collect identifiers
+            const ids = text.match(PATTERNS.identifier);
+            if (ids) {
+                ids.forEach((id) => identifiers.add(id));
+            }
+        }
+        return {
+            nestingDepth: maxNesting,
+            branchingFactor,
+            lineCount: endLine - startLine + 1,
+            identifierCount: identifiers.size,
+            callCount,
+        };
+    }
+    /**
+     * Calculate complexity score from factors
+     */
+    calculateScore(factors) {
+        const score = factors.nestingDepth * WEIGHTS.nestingDepth +
+            factors.branchingFactor * WEIGHTS.branchingFactor +
+            factors.lineCount * WEIGHTS.lineCount +
+            factors.identifierCount * WEIGHTS.identifierCount +
+            factors.callCount * WEIGHTS.callCount;
+        return Math.min(100, Math.round(score));
+    }
+    /**
+     * Get suggestion based on factors
+     */
+    getSuggestion(factors, score) {
+        if (score < THRESHOLDS.medium) {
+            return undefined;
+        }
+        if (factors.nestingDepth > 4) {
+            return 'Deep nesting detected. Consider extracting nested logic into separate functions.';
+        }
+        if (factors.lineCount > 50) {
+            return 'Long function detected. Consider breaking it into smaller, focused functions.';
+        }
+        if (factors.branchingFactor > 10) {
+            return 'High branching complexity. Consider using a lookup table, strategy pattern, or polymorphism.';
+        }
+        if (factors.callCount > 20) {
+            return 'Many function calls. Consider if some operations can be combined or simplified.';
+        }
+        if (score >= THRESHOLDS.high) {
+            return 'High cognitive complexity. This code may be difficult to understand and maintain.';
+        }
+        return undefined;
+    }
+    /**
+     * Find hotspot lines (lines in high-complexity regions)
+     */
+    findHotspots(regions) {
+        const hotspots = [];
+        for (const region of regions) {
+            if (region.score >= THRESHOLDS.high) {
+                for (let i = region.startLine; i <= region.endLine; i++) {
+                    hotspots.push(i);
+                }
+            }
+        }
+        return hotspots;
+    }
+    /**
+     * Calculate overall complexity
+     */
+    calculateOverall(regions, _totalLines) {
+        if (regions.length === 0)
+            return 0;
+        // Weighted average based on region size
+        let totalWeight = 0;
+        let weightedSum = 0;
+        for (const region of regions) {
+            const weight = region.endLine - region.startLine + 1;
+            weightedSum += region.score * weight;
+            totalWeight += weight;
+        }
+        // Normalize to total lines
+        const avgScore = totalWeight > 0 ? weightedSum / totalWeight : 0;
+        // Boost score slightly for files with many high-complexity regions
+        const highComplexityCount = regions.filter((r) => r.score >= THRESHOLDS.high).length;
+        const boost = Math.min(10, highComplexityCount * 2);
+        return Math.min(100, Math.round(avgScore + boost));
+    }
+    /**
+     * Get complexity level from score
+     */
+    getLevel(score) {
+        if (score >= THRESHOLDS.critical)
+            return 'critical';
+        if (score >= THRESHOLDS.high)
+            return 'high';
+        if (score >= THRESHOLDS.medium)
+            return 'medium';
+        return 'low';
+    }
+}
+/**
+ * Create a new complexity analyzer
+ */
+export function createComplexityAnalyzer() {
+    return new ComplexityAnalyzer();
+}
+/**
+ * Singleton instance for convenience
+ */
+let defaultAnalyzer = null;
+export function getComplexityAnalyzer() {
+    if (!defaultAnalyzer) {
+        defaultAnalyzer = createComplexityAnalyzer();
+    }
+    return defaultAnalyzer;
+}

package/dist/components/editor/core/conflict-predictor.d.ts

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+import type { SemanticRegion } from './semantic-analyzer';
+/**
+ * User awareness state for conflict detection
+ */
+export interface UserAwareness {
+    /** User ID */
+    id: string;
+    /** User display name */
+    name: string;
+    /** User color */
+    color: string;
+    /** Whether this is an AI agent */
+    isAI: boolean;
+    /** Current cursor line */
+    cursorLine: number;
+    /** Current cursor column */
+    cursorColumn: number;
+    /** Last edit timestamp */
+    lastEditTime: number;
+    /** Lines edited in the last N seconds */
+    recentlyEditedLines: number[];
+}
+/**
+ * Conflict zone information
+ */
+export interface ConflictZone {
+    /** Unique zone ID */
+    id: string;
+    /** Start line of the conflict zone */
+    startLine: number;
+    /** End line of the conflict zone */
+    endLine: number;
+    /** Conflict probability (0-1) */
+    probability: number;
+    /** Severity level */
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    /** Users involved in the potential conflict */
+    participants: Array<{
+        userId: string;
+        userName: string;
+        color: string;
+        cursorLine: number;
+        lastEditTime: number;
+        isAI: boolean;
+    }>;
+    /** Semantic context of the conflict zone */
+    semanticUnit: string;
+    /** Suggested action */
+    suggestion?: string;
+}
+/**
+ * Conflict prediction configuration
+ */
+export interface ConflictPredictorConfig {
+    /** Time window for recent edits in ms (default: 30000) */
+    recentEditWindow: number;
+    /** Minimum proximity in lines to consider conflict (default: 10) */
+    proximityThreshold: number;
+    /** Probability threshold to show warning (default: 0.3) */
+    warningThreshold: number;
+    /** Enable AI conflict detection (default: true) */
+    includeAI: boolean;
+}
+/**
+ * Conflict Predictor class
+ */
+export declare class ConflictPredictor {
+    private config;
+    private listeners;
+    private lastZones;
+    constructor(config?: Partial<ConflictPredictorConfig>);
+    /**
+     * Predict conflict zones based on user awareness and semantic regions
+     */
+    predict(users: UserAwareness[], semanticRegions: SemanticRegion[]): ConflictZone[];
+    /**
+     * Get the last predicted zones
+     */
+    getLastZones(): ConflictZone[];
+    /**
+     * Subscribe to conflict zone changes
+     */
+    subscribe(listener: (zones: ConflictZone[]) => void): () => void;
+    /**
+     * Calculate conflict probability
+     */
+    private calculateProbability;
+    /**
+     * Calculate average pairwise proximity between cursor positions
+     */
+    private calculateAverageProximity;
+    /**
+     * Get severity level from probability
+     */
+    private getSeverity;
+    /**
+     * Get suggestion based on conflict state
+     */
+    private getSuggestion;
+    /**
+     * Detect proximity-based conflicts outside semantic regions
+     */
+    private detectProximityConflicts;
+    /**
+     * Calculate probability for proximity-based conflict
+     */
+    private calculateProximityProbability;
+    /**
+     * Merge overlapping conflict zones
+     */
+    private mergeOverlappingZones;
+    /**
+     * Merge participant lists, removing duplicates
+     */
+    private mergeParticipants;
+    /**
+     * Notify listeners of zone changes
+     */
+    private notifyListeners;
+}
+/**
+ * Create a conflict predictor instance
+ */
+export declare function createConflictPredictor(config?: Partial<ConflictPredictorConfig>): ConflictPredictor;
+/**
+ * Get the global conflict predictor
+ */
+export declare function getConflictPredictor(): ConflictPredictor;