@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/plugins/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Plugin System API
+ *
+ * A proposal-based plugin/extension system. Plugins move through a
+ * lifecycle (draft → review → testing → deployed) coordinated by a backend
+ * "plugin host" that you provide. See {@link createPluginLoader} and the
+ * plugin store for the HTTP/SSE contract the host is expected to implement.
+ *
+ * Plugins can be:
+ * 1. UI Components (server-rendered by the plugin host)
+ * 2. JS Modules (executed by the plugin host, out of band)
+ * 3. Actions (commands that can be invoked)
+ * 4. Providers (services that provide data/functionality)
+ */
+import type { PluginManifest, PluginInstance, PluginCommand, PluginPanel } from '../types';
+/**
+ * Plugin registry for managing loaded plugins
+ */
+declare class PluginRegistry {
+    private plugins;
+    private commands;
+    private panels;
+    /**
+     * Register a plugin instance
+     */
+    register(plugin: PluginInstance): void;
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginId: string): void;
+    /**
+     * Get a plugin by ID
+     */
+    get(pluginId: string): PluginInstance | undefined;
+    /**
+     * Get all plugins
+     */
+    getAll(): PluginInstance[];
+    /**
+     * Register a command
+     */
+    registerCommand(pluginId: string, command: PluginCommand): void;
+    /**
+     * Execute a command
+     */
+    executeCommand(commandId: string): Promise<void>;
+    /**
+     * Get all commands
+     */
+    getCommands(): PluginCommand[];
+    /**
+     * Register a panel
+     */
+    registerPanel(pluginId: string, panel: PluginPanel): void;
+    /**
+     * Get all panels
+     */
+    getPanels(): PluginPanel[];
+    /**
+     * Get panels by position
+     */
+    getPanelsByPosition(position: 'left' | 'right' | 'bottom'): PluginPanel[];
+}
+export declare const pluginRegistry: PluginRegistry;
+/**
+ * Plugin loader for server-rendered components served by the plugin host
+ */
+export interface PluginLoader {
+    /**
+     * Load a plugin component from the server
+     */
+    loadComponent(proposalId: string, componentPath: string): Promise<{
+        default: unknown;
+    }>;
+    /**
+     * Load a plugin module from the server
+     */
+    loadModule(proposalId: string, entryPoint: string): Promise<Record<string, unknown>>;
+}
+/**
+ * Create a plugin loader bound to a plugin-host HTTP API.
+ *
+ * @param apiBase - Base path of the plugin host's REST API (same-origin).
+ *                  Defaults to `/api/plugins`.
+ */
+export declare function createPluginLoader(apiBase?: string): PluginLoader;
+/**
+ * Define a plugin manifest
+ */
+export declare function definePlugin(manifest: PluginManifest): PluginManifest;
+/**
+ * Define a plugin command
+ */
+export declare function defineCommand(command: Omit<PluginCommand, 'id'> & {
+    id: string;
+}): PluginCommand;
+/**
+ * Define a plugin panel
+ */
+export declare function definePanel(panel: Omit<PluginPanel, 'id'> & {
+    id: string;
+}): PluginPanel;
+export {};

package/dist/plugins/index.js

@@ -0,0 +1,153 @@
+/**
+ * Plugin System API
+ *
+ * A proposal-based plugin/extension system. Plugins move through a
+ * lifecycle (draft → review → testing → deployed) coordinated by a backend
+ * "plugin host" that you provide. See {@link createPluginLoader} and the
+ * plugin store for the HTTP/SSE contract the host is expected to implement.
+ *
+ * Plugins can be:
+ * 1. UI Components (server-rendered by the plugin host)
+ * 2. JS Modules (executed by the plugin host, out of band)
+ * 3. Actions (commands that can be invoked)
+ * 4. Providers (services that provide data/functionality)
+ */
+/**
+ * Plugin registry for managing loaded plugins
+ */
+class PluginRegistry {
+    plugins = new Map();
+    commands = new Map();
+    panels = new Map();
+    /**
+     * Register a plugin instance
+     */
+    register(plugin) {
+        this.plugins.set(plugin.id, plugin);
+    }
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (plugin) {
+            plugin.dispose?.();
+            this.plugins.delete(pluginId);
+            // Remove associated commands and panels
+            for (const [id] of this.commands) {
+                if (id.startsWith(`${pluginId}:`)) {
+                    this.commands.delete(id);
+                }
+            }
+            for (const [id] of this.panels) {
+                if (id.startsWith(`${pluginId}:`)) {
+                    this.panels.delete(id);
+                }
+            }
+        }
+    }
+    /**
+     * Get a plugin by ID
+     */
+    get(pluginId) {
+        return this.plugins.get(pluginId);
+    }
+    /**
+     * Get all plugins
+     */
+    getAll() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * Register a command
+     */
+    registerCommand(pluginId, command) {
+        const fullId = `${pluginId}:${command.id}`;
+        this.commands.set(fullId, { ...command, id: fullId });
+    }
+    /**
+     * Execute a command
+     */
+    async executeCommand(commandId) {
+        const command = this.commands.get(commandId);
+        if (command) {
+            await command.handler();
+        }
+    }
+    /**
+     * Get all commands
+     */
+    getCommands() {
+        return Array.from(this.commands.values());
+    }
+    /**
+     * Register a panel
+     */
+    registerPanel(pluginId, panel) {
+        const fullId = `${pluginId}:${panel.id}`;
+        this.panels.set(fullId, { ...panel, id: fullId });
+    }
+    /**
+     * Get all panels
+     */
+    getPanels() {
+        return Array.from(this.panels.values());
+    }
+    /**
+     * Get panels by position
+     */
+    getPanelsByPosition(position) {
+        return this.getPanels().filter((p) => p.position === position);
+    }
+}
+// Global plugin registry
+export const pluginRegistry = new PluginRegistry();
+/**
+ * Create a plugin loader bound to a plugin-host HTTP API.
+ *
+ * @param apiBase - Base path of the plugin host's REST API (same-origin).
+ *                  Defaults to `/api/plugins`.
+ */
+export function createPluginLoader(apiBase = '/api/plugins') {
+    return {
+        async loadComponent(proposalId, componentPath) {
+            const url = `${apiBase}/plugins/${proposalId}/component?path=${encodeURIComponent(componentPath)}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to load component: ${response.status}`);
+            }
+            // The server returns a compiled Svelte component
+            // (the plugin host compiles and returns the component)
+            const module = await response.json();
+            return module;
+        },
+        async loadModule(proposalId, entryPoint) {
+            const url = `${apiBase}/plugins/${proposalId}/module?entry=${encodeURIComponent(entryPoint)}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to load module: ${response.status}`);
+            }
+            // The server executes the module in a sandbox and returns the exports
+            const exports = await response.json();
+            return exports;
+        }
+    };
+}
+/**
+ * Define a plugin manifest
+ */
+export function definePlugin(manifest) {
+    return manifest;
+}
+/**
+ * Define a plugin command
+ */
+export function defineCommand(command) {
+    return command;
+}
+/**
+ * Define a plugin panel
+ */
+export function definePanel(panel) {
+    return panel;
+}

package/dist/services/error-handling.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Error Handling Service
+ *
+ * Provides structured error types, recovery strategies, and user-friendly error messages.
+ */
+export type VFSErrorCode = 'NETWORK_ERROR' | 'CONNECTION_LOST' | 'TIMEOUT' | 'FILE_LOCKED' | 'LOCK_EXPIRED' | 'LOCK_CONFLICT' | 'VERSION_CONFLICT' | 'FILE_NOT_FOUND' | 'PERMISSION_DENIED' | 'WORKSPACE_NOT_FOUND' | 'INVALID_OPERATION' | 'SERVER_ERROR' | 'RATE_LIMITED' | 'UNKNOWN';
+export interface VFSError extends Error {
+    code: VFSErrorCode;
+    statusCode?: number;
+    path?: string;
+    workspaceId?: string;
+    retryable: boolean;
+    userMessage: string;
+    technicalDetails?: string;
+    recoveryOptions: RecoveryOption[];
+}
+export interface RecoveryOption {
+    id: string;
+    label: string;
+    description: string;
+    action: 'retry' | 'force' | 'merge' | 'discard' | 'refresh' | 'wait' | 'cancel';
+    recommended?: boolean;
+    dangerous?: boolean;
+}
+/**
+ * Create a structured VFS error
+ */
+export declare function createVFSError(code: VFSErrorCode, message: string, options?: {
+    statusCode?: number;
+    path?: string;
+    workspaceId?: string;
+    cause?: Error;
+}): VFSError;
+/**
+ * Parse an error response into a VFSError
+ */
+export declare function parseError(error: unknown, context?: {
+    path?: string;
+    workspaceId?: string;
+}): VFSError;
+/**
+ * Check if error is a VFSError
+ */
+export declare function isVFSError(error: unknown): error is VFSError;
+/**
+ * Check if error is a conflict that needs user resolution
+ */
+export declare function isConflictError(error: VFSError): boolean;
+/**
+ * Check if error is recoverable with user action
+ */
+export declare function isRecoverableError(error: VFSError): boolean;
+export interface ErrorRecoveryHandler {
+    onRetry: () => Promise<void>;
+    onForce: () => Promise<void>;
+    onMerge: () => Promise<void>;
+    onDiscard: () => Promise<void>;
+    onRefresh: () => Promise<void>;
+    onWait: () => Promise<void>;
+    onCancel: () => void;
+}
+/**
+ * Execute a recovery action
+ */
+export declare function executeRecovery(option: RecoveryOption, handlers: Partial<ErrorRecoveryHandler>): Promise<void>;
+export interface AggregatedErrors {
+    total: number;
+    byCode: Map<VFSErrorCode, VFSError[]>;
+    retryable: VFSError[];
+    needsUserAction: VFSError[];
+    fatal: VFSError[];
+}
+/**
+ * Aggregate multiple errors for batch operations
+ */
+export declare function aggregateErrors(errors: VFSError[]): AggregatedErrors;
+export type ErrorLogLevel = 'error' | 'warn' | 'info' | 'debug';
+export interface ErrorLogEntry {
+    timestamp: number;
+    error: VFSError;
+    level: ErrorLogLevel;
+    context?: Record<string, unknown>;
+}
+/**
+ * Log an error
+ */
+export declare function logError(error: VFSError, level?: ErrorLogLevel, context?: Record<string, unknown>): void;
+/**
+ * Get recent errors
+ */
+export declare function getRecentErrors(limit?: number): ErrorLogEntry[];
+/**
+ * Clear error log
+ */
+export declare function clearErrorLog(): void;