@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/stores/ai-persistence.svelte.js

@@ -0,0 +1,334 @@
+/**
+ * AI Persistence Store
+ *
+ * Handles saving and loading AI conversations to IndexedDB/localStorage
+ */
+const DEFAULT_CONFIG = {
+    dbName: 'svelte-ide-ai',
+    storeName: 'conversations',
+    version: 1,
+    maxConversations: 100,
+    autoSave: true,
+    autoSaveDebounceMs: 1000
+};
+// State
+let config = $state({ ...DEFAULT_CONFIG });
+let db = $state(null);
+let initialized = $state(false);
+let error = $state(null);
+// Debounce timer for auto-save
+let saveTimer = null;
+/**
+ * Initialize the persistence layer
+ */
+export async function initPersistence(options) {
+    if (initialized)
+        return true;
+    config = { ...DEFAULT_CONFIG, ...options };
+    try {
+        // Check if IndexedDB is available
+        if (!('indexedDB' in globalThis)) {
+            console.warn('IndexedDB not available, using localStorage fallback');
+            initialized = true;
+            return true;
+        }
+        db = await openDatabase();
+        initialized = true;
+        error = null;
+        return true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : 'Failed to initialize persistence';
+        console.error('Persistence init error:', err);
+        return false;
+    }
+}
+/**
+ * Open IndexedDB database
+ */
+function openDatabase() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(config.dbName, config.version);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+        request.onupgradeneeded = (event) => {
+            const database = event.target.result;
+            // Create conversations store
+            if (!database.objectStoreNames.contains(config.storeName)) {
+                const store = database.createObjectStore(config.storeName, { keyPath: 'id' });
+                store.createIndex('updatedAt', 'updatedAt', { unique: false });
+                store.createIndex('starred', 'starred', { unique: false });
+            }
+        };
+    });
+}
+/**
+ * Save a conversation
+ */
+export async function saveConversation(conversation) {
+    if (!initialized)
+        await initPersistence();
+    const data = {
+        ...conversation,
+        updatedAt: new Date()
+    };
+    if (db) {
+        // IndexedDB
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(config.storeName, 'readwrite');
+            const store = transaction.objectStore(config.storeName);
+            const request = store.put(data);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    else {
+        // localStorage fallback
+        const conversations = getLocalStorageConversations();
+        const index = conversations.findIndex((c) => c.id === conversation.id);
+        if (index >= 0) {
+            conversations[index] = data;
+        }
+        else {
+            conversations.push(data);
+        }
+        setLocalStorageConversations(conversations);
+    }
+}
+/**
+ * Auto-save with debounce
+ */
+export function autoSaveConversation(conversation) {
+    if (!config.autoSave)
+        return;
+    if (saveTimer) {
+        clearTimeout(saveTimer);
+    }
+    saveTimer = setTimeout(() => {
+        saveConversation(conversation);
+        saveTimer = null;
+    }, config.autoSaveDebounceMs);
+}
+/**
+ * Load all conversations
+ */
+export async function loadConversations() {
+    if (!initialized)
+        await initPersistence();
+    if (db) {
+        // IndexedDB
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(config.storeName, 'readonly');
+            const store = transaction.objectStore(config.storeName);
+            const request = store.getAll();
+            request.onsuccess = () => {
+                const conversations = request.result;
+                // Sort by updatedAt descending
+                conversations.sort((a, b) => {
+                    const dateA = new Date(a.updatedAt).getTime();
+                    const dateB = new Date(b.updatedAt).getTime();
+                    return dateB - dateA;
+                });
+                resolve(conversations);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    else {
+        // localStorage fallback
+        return getLocalStorageConversations();
+    }
+}
+/**
+ * Load a single conversation by ID
+ */
+export async function loadConversation(id) {
+    if (!initialized)
+        await initPersistence();
+    if (db) {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(config.storeName, 'readonly');
+            const store = transaction.objectStore(config.storeName);
+            const request = store.get(id);
+            request.onsuccess = () => resolve(request.result || null);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    else {
+        const conversations = getLocalStorageConversations();
+        return conversations.find((c) => c.id === id) || null;
+    }
+}
+/**
+ * Delete a conversation
+ */
+export async function deleteConversation(id) {
+    if (!initialized)
+        await initPersistence();
+    if (db) {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(config.storeName, 'readwrite');
+            const store = transaction.objectStore(config.storeName);
+            const request = store.delete(id);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    else {
+        const conversations = getLocalStorageConversations();
+        const filtered = conversations.filter((c) => c.id !== id);
+        setLocalStorageConversations(filtered);
+    }
+}
+/**
+ * Delete all conversations
+ */
+export async function clearAllConversations() {
+    if (!initialized)
+        await initPersistence();
+    if (db) {
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(config.storeName, 'readwrite');
+            const store = transaction.objectStore(config.storeName);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    else {
+        setLocalStorageConversations([]);
+    }
+}
+/**
+ * Search conversations
+ */
+export async function searchConversations(query) {
+    const conversations = await loadConversations();
+    const lowerQuery = query.toLowerCase();
+    return conversations.filter((conv) => {
+        // Search in title
+        if (conv.title.toLowerCase().includes(lowerQuery))
+            return true;
+        // Search in messages
+        return conv.messages.some((msg) => msg.content.toLowerCase().includes(lowerQuery));
+    });
+}
+/**
+ * Get starred conversations
+ */
+export async function getStarredConversations() {
+    const conversations = await loadConversations();
+    return conversations.filter((c) => c.starred);
+}
+/**
+ * Star/unstar a conversation
+ */
+export async function toggleStarConversation(id, starred) {
+    const conversation = await loadConversation(id);
+    if (conversation) {
+        await saveConversation({ ...conversation, starred });
+    }
+}
+/**
+ * Export conversation to JSON
+ */
+export function exportConversationJSON(conversation) {
+    return JSON.stringify(conversation, null, 2);
+}
+/**
+ * Export conversation to Markdown
+ */
+export function exportConversationMarkdown(conversation) {
+    const lines = [
+        `# ${conversation.title}`,
+        '',
+        `*Created: ${new Date(conversation.createdAt).toLocaleString()}*`,
+        `*Updated: ${new Date(conversation.updatedAt).toLocaleString()}*`,
+        '',
+        '---',
+        ''
+    ];
+    for (const message of conversation.messages) {
+        const role = message.role === 'user' ? 'You' : message.role === 'assistant' ? 'AI' : message.role;
+        const time = new Date(message.timestamp).toLocaleTimeString();
+        lines.push(`## ${role} *${time}*`);
+        lines.push('');
+        lines.push(message.content);
+        lines.push('');
+        if (message.toolCalls && message.toolCalls.length > 0) {
+            lines.push('### Tool Calls');
+            for (const tool of message.toolCalls) {
+                lines.push(`- **${tool.name}**: \`${JSON.stringify(tool.arguments)}\``);
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Import conversation from JSON
+ */
+export async function importConversationJSON(json) {
+    try {
+        const conversation = JSON.parse(json);
+        // Validate required fields
+        if (!conversation.id || !conversation.title || !Array.isArray(conversation.messages)) {
+            throw new Error('Invalid conversation format');
+        }
+        // Generate new ID to avoid conflicts
+        conversation.id = crypto.randomUUID();
+        conversation.createdAt = new Date();
+        conversation.updatedAt = new Date();
+        await saveConversation(conversation);
+        return conversation;
+    }
+    catch (err) {
+        console.error('Failed to import conversation:', err);
+        return null;
+    }
+}
+/**
+ * Prune old conversations to stay under max limit
+ */
+export async function pruneOldConversations() {
+    const conversations = await loadConversations();
+    if (conversations.length <= config.maxConversations) {
+        return 0;
+    }
+    // Sort by updatedAt and keep starred ones
+    const toDelete = conversations
+        .filter((c) => !c.starred)
+        .slice(config.maxConversations);
+    for (const conv of toDelete) {
+        await deleteConversation(conv.id);
+    }
+    return toDelete.length;
+}
+// localStorage helpers
+function getLocalStorageConversations() {
+    try {
+        const data = localStorage.getItem('ai-conversations');
+        return data ? JSON.parse(data) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function setLocalStorageConversations(conversations) {
+    try {
+        localStorage.setItem('ai-conversations', JSON.stringify(conversations));
+    }
+    catch (err) {
+        console.error('Failed to save to localStorage:', err);
+    }
+}
+// Getters for reactive state
+export function isInitialized() {
+    return initialized;
+}
+export function getError() {
+    return error;
+}
+export function getConfig() {
+    return config;
+}

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

@@ -0,0 +1,140 @@
+/**
+ * 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.
+ */
+import type { AIMessage, AIConversation, AIContext, AITool, AIPanelConfig, AIEditSession, AISuggestion } from '../types';
+export declare function getConversations(): AIConversation[];
+export declare function getActiveConversationId(): string | null;
+export declare function getActiveConversation(): AIConversation | null;
+export declare function getMessages(): AIMessage[];
+export declare function getTools(): AITool[];
+export declare function getConfig(): AIPanelConfig;
+export declare function getEditSessions(): AIEditSession[];
+export declare function getActiveEditSessions(): AIEditSession[];
+export declare function getSuggestions(): AISuggestion[];
+export declare function getIsStreaming(): boolean;
+export declare function getIsPanelOpen(): boolean;
+export declare function getError(): string | null;
+export declare const conversations: {
+    readonly current: AIConversation[];
+};
+export declare const activeConversationId: {
+    readonly current: string | null;
+};
+export declare const activeConversation: {
+    readonly current: AIConversation | null;
+};
+export declare const messages: {
+    readonly current: AIMessage[];
+};
+export declare const tools: {
+    readonly current: AITool[];
+};
+export declare const config: {
+    readonly current: AIPanelConfig;
+};
+export declare const editSessions: {
+    readonly current: AIEditSession[];
+};
+export declare const activeEditSessions: {
+    readonly current: AIEditSession[];
+};
+export declare const suggestions: {
+    readonly current: AISuggestion[];
+};
+export declare const isStreaming: {
+    readonly current: boolean;
+};
+export declare const isPanelOpen: {
+    readonly current: boolean;
+};
+export declare const error: {
+    readonly current: string | null;
+};
+/**
+ * Create a new conversation
+ */
+export declare function createConversation(title?: string, context?: AIContext): string;
+/**
+ * Set active conversation
+ */
+export declare function setActiveConversation(conversationId: string | null): void;
+/**
+ * Delete a conversation
+ */
+export declare function deleteConversation(conversationId: string): void;
+/**
+ * Add a message to the active conversation
+ */
+export declare function addMessage(message: Omit<AIMessage, 'id' | 'timestamp'>): string;
+/**
+ * Update a message (for streaming)
+ */
+export declare function updateMessage(messageId: string, updates: Partial<AIMessage>): void;
+/**
+ * Send a user message and get AI response
+ */
+export declare function sendMessage(content: string, context?: AIContext): Promise<void>;
+/**
+ * Register a tool
+ */
+export declare function registerTool(tool: AITool): void;
+/**
+ * Unregister a tool
+ */
+export declare function unregisterTool(toolName: string): void;
+/**
+ * Update AI configuration
+ */
+export declare function updateConfig(updates: Partial<AIPanelConfig>): void;
+/**
+ * Toggle AI panel visibility
+ */
+export declare function togglePanel(): void;
+/**
+ * Open AI panel
+ */
+export declare function openPanel(): void;
+/**
+ * Close AI panel
+ */
+export declare function closePanel(): void;
+/**
+ * Start an AI edit session
+ */
+export declare function startEditSession(conversationId: string, filePath: string, originalContent: string): string;
+/**
+ * Update edit session status
+ */
+export declare function updateEditSession(sessionId: string, updates: Partial<AIEditSession>): void;
+/**
+ * Complete an edit session
+ */
+export declare function completeEditSession(sessionId: string, proposedContent: string, diff?: string): void;
+/**
+ * Apply or reject an edit session
+ */
+export declare function resolveEditSession(sessionId: string, apply: boolean): void;
+/**
+ * Add a suggestion
+ */
+export declare function addSuggestion(suggestion: Omit<AISuggestion, 'id'>): string;
+/**
+ * Remove a suggestion
+ */
+export declare function removeSuggestion(suggestionId: string): void;
+/**
+ * Clear all suggestions
+ */
+export declare function clearSuggestions(): void;
+/**
+ * Update conversation context
+ */
+export declare function updateContext(context: Partial<AIContext>): void;
+/**
+ * Clear error state
+ */
+export declare function clearError(): void;