@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/ai-awareness.d.ts

@@ -0,0 +1,176 @@
+/**
+ * AI Awareness System
+ *
+ * Tracks AI agent focus, attention, and activity within the editor.
+ * Enables "Ghost Pair" visualization - showing developers where
+ * AI agents are "looking" and what they're considering.
+ *
+ * Based on CRDT awareness patterns for real-time collaboration.
+ */
+import type { Position, Selection } from './state';
+/**
+ * Types of AI attention/activity
+ */
+export type AIAttentionType = 'reading' | 'thinking' | 'writing' | 'reviewing' | 'waiting';
+/**
+ * AI focus region - where the AI is paying attention
+ */
+export interface AIFocusRegion {
+    /** Start line (0-based) */
+    startLine: number;
+    /** End line (0-based) */
+    endLine: number;
+    /** Start column (0-based, optional for line-based focus) */
+    startColumn?: number;
+    /** End column (0-based, optional for line-based focus) */
+    endColumn?: number;
+    /** Attention intensity (0-1, used for glow effects) */
+    intensity: number;
+    /** Type of attention */
+    type: AIAttentionType;
+    /** Optional label for the region */
+    label?: string;
+}
+/**
+ * AI cursor position - the AI's "virtual cursor"
+ */
+export interface AICursor {
+    /** Current position */
+    position: Position;
+    /** Optional selection range */
+    selection?: Selection;
+    /** Cursor color (hex) */
+    color: string;
+    /** Whether cursor is visible */
+    visible: boolean;
+    /** Animation state */
+    animation: 'idle' | 'moving' | 'typing' | 'thinking';
+}
+/**
+ * AI agent awareness state
+ */
+export interface AIAwareness {
+    /** Unique agent ID */
+    agentId: string;
+    /** Agent display name */
+    agentName: string;
+    /** Agent color for visualization */
+    color: string;
+    /** Current attention type */
+    attentionType: AIAttentionType;
+    /** AI cursor position */
+    cursor: AICursor | null;
+    /** Regions the AI is focused on */
+    focusRegions: AIFocusRegion[];
+    /** Current activity description */
+    activity: string;
+    /** Confidence level (0-1) for current action */
+    confidence: number;
+    /** Timestamp of last update */
+    lastUpdate: number;
+    /** Whether the agent is actively engaged with this file */
+    isActive: boolean;
+}
+/**
+ * Event types for AI awareness changes
+ */
+export type AIAwarenessEventType = 'cursor-move' | 'focus-change' | 'attention-change' | 'activity-change' | 'agent-join' | 'agent-leave';
+/**
+ * AI awareness event
+ */
+export interface AIAwarenessEvent {
+    type: AIAwarenessEventType;
+    agentId: string;
+    timestamp: number;
+    data?: unknown;
+}
+/**
+ * Callback type for awareness changes
+ */
+export type AIAwarenessCallback = (agents: Map<string, AIAwareness>) => void;
+/**
+ * AI Awareness Manager
+ *
+ * Manages AI agent presence and focus within the editor.
+ * Supports multiple concurrent AI agents.
+ */
+export declare class AIAwarenessManager {
+    private agents;
+    private listeners;
+    private eventHistory;
+    private maxHistorySize;
+    /**
+     * Register or update an AI agent
+     */
+    setAgent(awareness: AIAwareness): void;
+    /**
+     * Remove an AI agent
+     */
+    removeAgent(agentId: string): void;
+    /**
+     * Update AI cursor position
+     */
+    updateCursor(agentId: string, cursor: AICursor): void;
+    /**
+     * Update AI focus regions
+     */
+    updateFocusRegions(agentId: string, regions: AIFocusRegion[]): void;
+    /**
+     * Update AI attention type
+     */
+    updateAttention(agentId: string, type: AIAttentionType, activity?: string): void;
+    /**
+     * Get all active AI agents
+     */
+    getAgents(): Map<string, AIAwareness>;
+    /**
+     * Get a specific agent
+     */
+    getAgent(agentId: string): AIAwareness | undefined;
+    /**
+     * Get active agents (updated within last 30 seconds)
+     */
+    getActiveAgents(): AIAwareness[];
+    /**
+     * Subscribe to awareness changes
+     */
+    onChange(callback: AIAwarenessCallback): () => void;
+    /**
+     * Get recent events
+     */
+    getRecentEvents(count?: number): AIAwarenessEvent[];
+    /**
+     * Clear all agents
+     */
+    clear(): void;
+    /**
+     * Record an event
+     */
+    private recordEvent;
+    /**
+     * Notify all listeners
+     */
+    private notifyListeners;
+}
+/**
+ * Default AI agent colors
+ */
+export declare const AI_AGENT_COLORS: {
+    claude: string;
+    assistant: string;
+    copilot: string;
+    default: string;
+};
+/**
+ * Get color for AI agent
+ */
+export declare function getAgentColor(agentName: string): string;
+/**
+ * Create a new AI awareness state
+ */
+export declare function createAIAwareness(agentId: string, agentName: string, options?: Partial<Omit<AIAwareness, 'agentId' | 'agentName'>>): AIAwareness;
+export declare function getAIAwarenessManager(): AIAwarenessManager;
+/**
+ * Create a new manager instance
+ */
+export declare function createAIAwarenessManager(): AIAwarenessManager;

package/dist/components/editor/core/ai-awareness.js

@@ -0,0 +1,210 @@
+/**
+ * AI Awareness System
+ *
+ * Tracks AI agent focus, attention, and activity within the editor.
+ * Enables "Ghost Pair" visualization - showing developers where
+ * AI agents are "looking" and what they're considering.
+ *
+ * Based on CRDT awareness patterns for real-time collaboration.
+ */
+/**
+ * AI Awareness Manager
+ *
+ * Manages AI agent presence and focus within the editor.
+ * Supports multiple concurrent AI agents.
+ */
+export class AIAwarenessManager {
+    agents = new Map();
+    listeners = new Set();
+    eventHistory = [];
+    maxHistorySize = 100;
+    /**
+     * Register or update an AI agent
+     */
+    setAgent(awareness) {
+        const existing = this.agents.get(awareness.agentId);
+        this.agents.set(awareness.agentId, {
+            ...awareness,
+            lastUpdate: Date.now()
+        });
+        const eventType = existing ? 'activity-change' : 'agent-join';
+        this.recordEvent(eventType, awareness.agentId);
+        this.notifyListeners();
+    }
+    /**
+     * Remove an AI agent
+     */
+    removeAgent(agentId) {
+        if (this.agents.has(agentId)) {
+            this.agents.delete(agentId);
+            this.recordEvent('agent-leave', agentId);
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Update AI cursor position
+     */
+    updateCursor(agentId, cursor) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.cursor = cursor;
+            agent.lastUpdate = Date.now();
+            this.recordEvent('cursor-move', agentId, { position: cursor.position });
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Update AI focus regions
+     */
+    updateFocusRegions(agentId, regions) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.focusRegions = regions;
+            agent.lastUpdate = Date.now();
+            this.recordEvent('focus-change', agentId, { regionCount: regions.length });
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Update AI attention type
+     */
+    updateAttention(agentId, type, activity) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.attentionType = type;
+            if (activity !== undefined) {
+                agent.activity = activity;
+            }
+            agent.lastUpdate = Date.now();
+            this.recordEvent('attention-change', agentId, { type, activity });
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Get all active AI agents
+     */
+    getAgents() {
+        return new Map(this.agents);
+    }
+    /**
+     * Get a specific agent
+     */
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    /**
+     * Get active agents (updated within last 30 seconds)
+     */
+    getActiveAgents() {
+        const now = Date.now();
+        const staleThreshold = 30000; // 30 seconds
+        return Array.from(this.agents.values()).filter((agent) => agent.isActive && now - agent.lastUpdate < staleThreshold);
+    }
+    /**
+     * Subscribe to awareness changes
+     */
+    onChange(callback) {
+        this.listeners.add(callback);
+        return () => {
+            this.listeners.delete(callback);
+        };
+    }
+    /**
+     * Get recent events
+     */
+    getRecentEvents(count = 10) {
+        return this.eventHistory.slice(-count);
+    }
+    /**
+     * Clear all agents
+     */
+    clear() {
+        this.agents.clear();
+        this.eventHistory = [];
+        this.notifyListeners();
+    }
+    /**
+     * Record an event
+     */
+    recordEvent(type, agentId, data) {
+        this.eventHistory.push({
+            type,
+            agentId,
+            timestamp: Date.now(),
+            data
+        });
+        // Trim history
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory = this.eventHistory.slice(-this.maxHistorySize);
+        }
+    }
+    /**
+     * Notify all listeners
+     */
+    notifyListeners() {
+        const snapshot = this.getAgents();
+        for (const callback of this.listeners) {
+            try {
+                callback(snapshot);
+            }
+            catch (error) {
+                console.error('[AIAwarenessManager] Listener error:', error);
+            }
+        }
+    }
+}
+/**
+ * Default AI agent colors
+ */
+export const AI_AGENT_COLORS = {
+    claude: '#8B5CF6', // Purple (Anthropic brand)
+    assistant: '#3B82F6', // Blue
+    copilot: '#22C55E', // Green
+    default: '#F59E0B' // Amber
+};
+/**
+ * Get color for AI agent
+ */
+export function getAgentColor(agentName) {
+    const normalized = agentName.toLowerCase();
+    if (normalized.includes('claude'))
+        return AI_AGENT_COLORS.claude;
+    if (normalized.includes('copilot'))
+        return AI_AGENT_COLORS.copilot;
+    if (normalized.includes('assistant'))
+        return AI_AGENT_COLORS.assistant;
+    return AI_AGENT_COLORS.default;
+}
+/**
+ * Create a new AI awareness state
+ */
+export function createAIAwareness(agentId, agentName, options = {}) {
+    return {
+        agentId,
+        agentName,
+        color: options.color ?? getAgentColor(agentName),
+        attentionType: options.attentionType ?? 'reading',
+        cursor: options.cursor ?? null,
+        focusRegions: options.focusRegions ?? [],
+        activity: options.activity ?? '',
+        confidence: options.confidence ?? 0.5,
+        lastUpdate: Date.now(),
+        isActive: options.isActive ?? true
+    };
+}
+/**
+ * Singleton instance
+ */
+let defaultManager = null;
+export function getAIAwarenessManager() {
+    if (!defaultManager) {
+        defaultManager = new AIAwarenessManager();
+    }
+    return defaultManager;
+}
+/**
+ * Create a new manager instance
+ */
+export function createAIAwarenessManager() {
+    return new AIAwarenessManager();
+}

package/dist/components/editor/core/bracket-healer.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Bracket Healer
+ *
+ * Intelligent bracket completion and morphing system.
+ * Detects mismatched brackets and suggests "ghost brackets"
+ * to heal document structure.
+ */
+import type { Position } from './state';
+/**
+ * Bracket pair definition
+ */
+export interface BracketPair {
+    open: string;
+    close: string;
+    /** Language-specific (e.g., JSX angle brackets) */
+    language?: string[];
+}
+/**
+ * Bracket match result
+ */
+export interface BracketMatch {
+    /** Opening bracket position */
+    openPos: Position;
+    /** Closing bracket position (null if unmatched) */
+    closePos: Position | null;
+    /** Bracket type */
+    type: BracketPair;
+    /** Whether this pair is complete */
+    isComplete: boolean;
+    /** Nesting depth */
+    depth: number;
+}
+/**
+ * Ghost bracket suggestion
+ */
+export interface GhostBracket {
+    /** Unique ID */
+    id: string;
+    /** Position where ghost should appear */
+    position: Position;
+    /** Character to insert */
+    character: string;
+    /** Type: 'open' or 'close' */
+    type: 'open' | 'close';
+    /** Matching bracket position */
+    matchPosition: Position;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Suggested fix reason */
+    reason: string;
+    /** Whether user dismissed this suggestion */
+    dismissed: boolean;
+}
+/**
+ * Bracket mismatch diagnostic
+ */
+export interface BracketMismatch {
+    /** Position of the problematic bracket */
+    position: Position;
+    /** The bracket character */
+    character: string;
+    /** Expected bracket (if mismatched) */
+    expected?: string;
+    /** Type of issue */
+    issue: 'unclosed' | 'unexpected' | 'mismatched';
+    /** Severity */
+    severity: 'error' | 'warning' | 'info';
+}
+/**
+ * Bracket healer state
+ */
+export interface BracketHealerState {
+    /** All bracket matches */
+    matches: BracketMatch[];
+    /** Ghost bracket suggestions */
+    ghosts: GhostBracket[];
+    /** Mismatch diagnostics */
+    mismatches: BracketMismatch[];
+    /** Whether healing is enabled */
+    enabled: boolean;
+}
+/**
+ * Bracket healer configuration
+ */
+export interface BracketHealerConfig {
+    /** Bracket pairs to match */
+    pairs: BracketPair[];
+    /** Minimum confidence to show ghost */
+    minConfidence: number;
+    /** Maximum ghost suggestions */
+    maxGhosts: number;
+    /** Debounce time for analysis */
+    debounceMs: number;
+}
+/**
+ * Bracket Healer Manager
+ */
+export declare class BracketHealer {
+    private config;
+    private state;
+    private language;
+    private debounceTimer;
+    private listeners;
+    constructor(config?: Partial<BracketHealerConfig>);
+    /**
+     * Set current language
+     */
+    setLanguage(language: string): void;
+    /**
+     * Enable/disable healing
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Analyze document content
+     */
+    analyze(content: string): void;
+    /**
+     * Analyze immediately (no debounce)
+     */
+    analyzeImmediate(content: string): void;
+    /**
+     * Perform bracket analysis
+     */
+    private performAnalysis;
+    /**
+     * Extract all brackets from content
+     */
+    private extractBrackets;
+    /**
+     * Get bracket pairs active for current language
+     */
+    private getActivePairs;
+    /**
+     * Match brackets and find mismatches
+     */
+    private matchBrackets;
+    /**
+     * Generate ghost bracket suggestions
+     */
+    private generateGhosts;
+    /**
+     * Suggest where to place a closing bracket
+     */
+    private suggestClosingBracket;
+    /**
+     * Get line indentation level
+     */
+    private getIndentation;
+    /**
+     * Accept a ghost bracket suggestion
+     */
+    acceptGhost(id: string): GhostBracket | null;
+    /**
+     * Dismiss a ghost bracket suggestion
+     */
+    dismissGhost(id: string): void;
+    /**
+     * Get current state
+     */
+    getState(): BracketHealerState;
+    /**
+     * Get ghost brackets (non-dismissed only)
+     */
+    getActiveGhosts(): GhostBracket[];
+    /**
+     * Get mismatches
+     */
+    getMismatches(): BracketMismatch[];
+    /**
+     * Find matching bracket for position
+     */
+    findMatchingBracket(position: Position): Position | null;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener: (state: BracketHealerState) => void): () => void;
+    /**
+     * Notify listeners
+     */
+    private notify;
+    /**
+     * Destroy and cleanup
+     */
+    destroy(): void;
+}
+/**
+ * Create a bracket healer instance
+ */
+export declare function createBracketHealer(config?: Partial<BracketHealerConfig>): BracketHealer;