@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/stores/ai.svelte.js

@@ -0,0 +1,383 @@
+/**
+ * AI store using Svelte 5 runes
+ * Manages AI conversations, messages, and tools
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+// Default configuration
+const defaultConfig = {
+    endpoint: '/api/chat',
+    model: 'claude-3-5-sonnet',
+    systemPrompt: 'You are a helpful coding assistant integrated into an IDE.',
+    tools: [],
+    maxTokens: 4096,
+    temperature: 0.7,
+    streaming: true
+};
+// Reactive state
+let state = $state({
+    conversations: [],
+    activeConversationId: null,
+    tools: new Map(),
+    config: { ...defaultConfig },
+    editSessions: [],
+    suggestions: [],
+    isStreaming: false,
+    isPanelOpen: false,
+    error: null
+});
+// Getter functions for derived values (Svelte 5 module-safe)
+export function getConversations() {
+    return state.conversations;
+}
+export function getActiveConversationId() {
+    return state.activeConversationId;
+}
+export function getActiveConversation() {
+    return state.conversations.find((c) => c.id === state.activeConversationId) ?? null;
+}
+export function getMessages() {
+    const active = getActiveConversation();
+    return active?.messages ?? [];
+}
+export function getTools() {
+    return Array.from(state.tools.values());
+}
+export function getConfig() {
+    return state.config;
+}
+export function getEditSessions() {
+    return state.editSessions;
+}
+export function getActiveEditSessions() {
+    return state.editSessions.filter((s) => s.status === 'editing');
+}
+export function getSuggestions() {
+    return state.suggestions;
+}
+export function getIsStreaming() {
+    return state.isStreaming;
+}
+export function getIsPanelOpen() {
+    return state.isPanelOpen;
+}
+export function getError() {
+    return state.error;
+}
+// Legacy aliases for backward compatibility
+export const conversations = { get current() { return getConversations(); } };
+export const activeConversationId = { get current() { return getActiveConversationId(); } };
+export const activeConversation = { get current() { return getActiveConversation(); } };
+export const messages = { get current() { return getMessages(); } };
+export const tools = { get current() { return getTools(); } };
+export const config = { get current() { return getConfig(); } };
+export const editSessions = { get current() { return getEditSessions(); } };
+export const activeEditSessions = { get current() { return getActiveEditSessions(); } };
+export const suggestions = { get current() { return getSuggestions(); } };
+export const isStreaming = { get current() { return getIsStreaming(); } };
+export const isPanelOpen = { get current() { return getIsPanelOpen(); } };
+export const error = { get current() { return getError(); } };
+/**
+ * Create a new conversation
+ */
+export function createConversation(title, context) {
+    const id = crypto.randomUUID();
+    const conversation = {
+        id,
+        title: title ?? 'New conversation',
+        messages: [],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        context
+    };
+    state.conversations = [...state.conversations, conversation];
+    state.activeConversationId = id;
+    return id;
+}
+/**
+ * Set active conversation
+ */
+export function setActiveConversation(conversationId) {
+    if (conversationId === null || state.conversations.some((c) => c.id === conversationId)) {
+        state.activeConversationId = conversationId;
+    }
+}
+/**
+ * Delete a conversation
+ */
+export function deleteConversation(conversationId) {
+    state.conversations = state.conversations.filter((c) => c.id !== conversationId);
+    if (state.activeConversationId === conversationId) {
+        state.activeConversationId = state.conversations[0]?.id ?? null;
+    }
+}
+/**
+ * Add a message to the active conversation
+ */
+export function addMessage(message) {
+    if (!state.activeConversationId) {
+        createConversation();
+    }
+    const id = crypto.randomUUID();
+    const newMessage = {
+        ...message,
+        id,
+        timestamp: new Date()
+    };
+    state.conversations = state.conversations.map((c) => c.id === state.activeConversationId
+        ? { ...c, messages: [...c.messages, newMessage], updatedAt: new Date() }
+        : c);
+    return id;
+}
+/**
+ * Update a message (for streaming)
+ */
+export function updateMessage(messageId, updates) {
+    state.conversations = state.conversations.map((c) => c.id === state.activeConversationId
+        ? {
+            ...c,
+            messages: c.messages.map((m) => (m.id === messageId ? { ...m, ...updates } : m)),
+            updatedAt: new Date()
+        }
+        : c);
+}
+/**
+ * Send a user message and get AI response
+ */
+export async function sendMessage(content, context) {
+    if (!content.trim())
+        return;
+    // Add user message
+    addMessage({ role: 'user', content });
+    // Create placeholder for assistant response
+    const assistantId = addMessage({
+        role: 'assistant',
+        content: '',
+        isStreaming: true
+    });
+    state.isStreaming = true;
+    state.error = null;
+    try {
+        const activeConv = getActiveConversation();
+        const response = await fetch(state.config.endpoint ?? '/api/chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...state.config.headers
+            },
+            body: JSON.stringify({
+                messages: activeConv?.messages.slice(0, -1) ?? [],
+                model: state.config.model,
+                systemPrompt: state.config.systemPrompt,
+                tools: Array.from(state.tools.values()).map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters
+                })),
+                maxTokens: state.config.maxTokens,
+                temperature: state.config.temperature,
+                context: context ?? activeConv?.context
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status}`);
+        }
+        if (state.config.streaming && response.body) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let fullContent = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value);
+                fullContent += chunk;
+                updateMessage(assistantId, {
+                    content: fullContent,
+                    isStreaming: true
+                });
+            }
+            updateMessage(assistantId, {
+                content: fullContent,
+                isStreaming: false
+            });
+        }
+        else {
+            const data = await response.json();
+            updateMessage(assistantId, {
+                content: data.content,
+                toolCalls: data.toolCalls,
+                isStreaming: false,
+                metadata: data.metadata
+            });
+            // Handle tool calls
+            if (data.toolCalls?.length) {
+                for (const toolCall of data.toolCalls) {
+                    await executeToolCall(toolCall.name, toolCall.arguments, toolCall.id);
+                }
+            }
+        }
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        state.error = errorMessage;
+        updateMessage(assistantId, {
+            content: '',
+            error: errorMessage,
+            isStreaming: false
+        });
+    }
+    finally {
+        state.isStreaming = false;
+    }
+}
+/**
+ * Execute a tool call
+ */
+async function executeToolCall(toolName, args, toolCallId) {
+    const tool = state.tools.get(toolName);
+    if (!tool) {
+        addMessage({
+            role: 'tool',
+            content: '',
+            toolResult: {
+                toolCallId,
+                result: null,
+                error: `Tool not found: ${toolName}`
+            }
+        });
+        return;
+    }
+    try {
+        const activeConv = getActiveConversation();
+        const result = await tool.handler(args, activeConv?.context ?? {});
+        addMessage({
+            role: 'tool',
+            content: '',
+            toolResult: {
+                toolCallId,
+                result
+            }
+        });
+    }
+    catch (err) {
+        addMessage({
+            role: 'tool',
+            content: '',
+            toolResult: {
+                toolCallId,
+                result: null,
+                error: err instanceof Error ? err.message : 'Tool execution failed'
+            }
+        });
+    }
+}
+/**
+ * Register a tool
+ */
+export function registerTool(tool) {
+    state.tools.set(tool.name, tool);
+}
+/**
+ * Unregister a tool
+ */
+export function unregisterTool(toolName) {
+    state.tools.delete(toolName);
+}
+/**
+ * Update AI configuration
+ */
+export function updateConfig(updates) {
+    state.config = { ...state.config, ...updates };
+}
+/**
+ * Toggle AI panel visibility
+ */
+export function togglePanel() {
+    state.isPanelOpen = !state.isPanelOpen;
+}
+/**
+ * Open AI panel
+ */
+export function openPanel() {
+    state.isPanelOpen = true;
+}
+/**
+ * Close AI panel
+ */
+export function closePanel() {
+    state.isPanelOpen = false;
+}
+/**
+ * Start an AI edit session
+ */
+export function startEditSession(conversationId, filePath, originalContent) {
+    const id = crypto.randomUUID();
+    const session = {
+        id,
+        conversationId,
+        filePath,
+        status: 'pending',
+        originalContent,
+        startedAt: new Date()
+    };
+    state.editSessions = [...state.editSessions, session];
+    return id;
+}
+/**
+ * Update edit session status
+ */
+export function updateEditSession(sessionId, updates) {
+    state.editSessions = state.editSessions.map((s) => s.id === sessionId ? { ...s, ...updates } : s);
+}
+/**
+ * Complete an edit session
+ */
+export function completeEditSession(sessionId, proposedContent, diff) {
+    state.editSessions = state.editSessions.map((s) => s.id === sessionId
+        ? { ...s, status: 'reviewing', proposedContent, diff, completedAt: new Date() }
+        : s);
+}
+/**
+ * Apply or reject an edit session
+ */
+export function resolveEditSession(sessionId, apply) {
+    state.editSessions = state.editSessions.map((s) => s.id === sessionId ? { ...s, status: apply ? 'applied' : 'rejected' } : s);
+}
+/**
+ * Add a suggestion
+ */
+export function addSuggestion(suggestion) {
+    const id = crypto.randomUUID();
+    state.suggestions = [...state.suggestions, { ...suggestion, id }];
+    return id;
+}
+/**
+ * Remove a suggestion
+ */
+export function removeSuggestion(suggestionId) {
+    state.suggestions = state.suggestions.filter((s) => s.id !== suggestionId);
+}
+/**
+ * Clear all suggestions
+ */
+export function clearSuggestions() {
+    state.suggestions = [];
+}
+/**
+ * Update conversation context
+ */
+export function updateContext(context) {
+    if (!state.activeConversationId)
+        return;
+    state.conversations = state.conversations.map((c) => c.id === state.activeConversationId
+        ? { ...c, context: { ...c.context, ...context }, updatedAt: new Date() }
+        : c);
+}
+/**
+ * Clear error state
+ */
+export function clearError() {
+    state.error = null;
+}

package/dist/stores/collaboration.svelte.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Collaboration store using Svelte 5 runes
+ * Manages CRDT-based real-time collaboration
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+import type { CollaborationConfig, CollaborationState, CollaborationUser, CollaboratorCursor, CollaboratorAwareness, AICollaborationSession, AIProposedChange, DocumentSnapshot, CollaborationEventHandler } from '../types';
+export declare function getConfig(): CollaborationConfig | null;
+export declare function getStatus(): CollaborationState['status'];
+export declare function getError(): string | null;
+export declare function getSynced(): boolean;
+export declare function getUsers(): CollaborationUser[];
+export declare function getCursors(): CollaboratorCursor[];
+export declare function getAwareness(): CollaboratorAwareness[];
+export declare function getAISessions(): AICollaborationSession[];
+export declare function getActiveAISessions(): AICollaborationSession[];
+export declare function getPendingChanges(): AIProposedChange[];
+export declare function getSnapshots(): DocumentSnapshot[];
+export declare function getLocalUser(): CollaborationUser | null;
+export declare function getIsConnected(): boolean;
+export declare function getOtherUsers(): CollaborationUser[];
+export declare const config: {
+    readonly current: CollaborationConfig | null;
+};
+export declare const status: {
+    readonly current: "error" | "connected" | "disconnected" | "connecting";
+};
+export declare const error: {
+    readonly current: string | null;
+};
+export declare const synced: {
+    readonly current: boolean;
+};
+export declare const users: {
+    readonly current: CollaborationUser[];
+};
+export declare const cursors: {
+    readonly current: CollaboratorCursor[];
+};
+export declare const awareness: {
+    readonly current: CollaboratorAwareness[];
+};
+export declare const aiSessions: {
+    readonly current: AICollaborationSession[];
+};
+export declare const activeAISessions: {
+    readonly current: AICollaborationSession[];
+};
+export declare const pendingChanges: {
+    readonly current: AIProposedChange[];
+};
+export declare const snapshots: {
+    readonly current: DocumentSnapshot[];
+};
+export declare const localUser: {
+    readonly current: CollaborationUser | null;
+};
+export declare const isConnected: {
+    readonly current: boolean;
+};
+export declare const otherUsers: {
+    readonly current: CollaborationUser[];
+};
+/**
+ * Initialize collaboration with config
+ */
+export declare function initialize(collabConfig: CollaborationConfig): void;
+/**
+ * Set connection status
+ */
+export declare function setStatus(newStatus: CollaborationState['status'], errorMsg?: string): void;
+/**
+ * Set synced state
+ */
+export declare function setSynced(syncedState: boolean): void;
+/**
+ * Add a user to the session
+ */
+export declare function addUser(user: CollaborationUser): void;
+/**
+ * Remove a user from the session
+ */
+export declare function removeUser(userId: string): void;
+/**
+ * Update cursor position for a user
+ */
+export declare function updateCursor(cursor: CollaboratorCursor): void;
+/**
+ * Update awareness for a user
+ */
+export declare function updateAwareness(awarenessData: CollaboratorAwareness): void;
+/**
+ * Update local user's cursor
+ */
+export declare function setLocalCursor(position: {
+    line: number;
+    column: number;
+}, selection?: {
+    anchor: {
+        line: number;
+        column: number;
+    };
+    head: {
+        line: number;
+        column: number;
+    };
+}): void;
+/**
+ * Update local user's awareness
+ */
+export declare function setLocalAwareness(updates: Partial<Omit<CollaboratorAwareness, 'userId' | 'user'>>): void;
+/**
+ * Start an AI collaboration session
+ */
+export declare function startAISession(documentId: string, aiUser: CollaborationUser): string;
+/**
+ * Update AI session status
+ */
+export declare function updateAISession(sessionId: string, updates: Partial<AICollaborationSession>): void;
+/**
+ * Set current task for AI session
+ */
+export declare function setAITask(sessionId: string, task: string): void;
+/**
+ * Propose a change from AI
+ */
+export declare function proposeAIChange(sessionId: string, change: Omit<AIProposedChange, 'id' | 'sessionId' | 'status'>): string;
+/**
+ * Review an AI proposed change
+ */
+export declare function reviewAIChange(changeId: string, approved: boolean, reviewerId: string): void;
+/**
+ * Complete an AI session
+ */
+export declare function completeAISession(sessionId: string): void;
+/**
+ * Cancel an AI session
+ */
+export declare function cancelAISession(sessionId: string): void;
+/**
+ * Create a document snapshot
+ */
+export declare function createSnapshot(documentId: string, content: string, reason?: DocumentSnapshot['reason']): string;
+/**
+ * Get snapshots for a document
+ */
+export declare function getDocumentSnapshots(documentId: string): DocumentSnapshot[];
+/**
+ * Subscribe to collaboration events
+ */
+export declare function onEvent(handler: CollaborationEventHandler): () => void;
+/**
+ * Disconnect and cleanup
+ */
+export declare function disconnect(): void;
+/**
+ * Reset collaboration state
+ */
+export declare function reset(): void;
+/**
+ * Get user color by index
+ */
+export declare function getUserColor(index: number): string;