lokicms-plugin-sql 1.0.0

package/dist/plugin.js

@@ -0,0 +1,798 @@
+/**
+ * LokiCMS SQL Plugin
+ *
+ * Universal SQL adapter with multi-database support, data federation,
+ * split storage, and vector capabilities.
+ */
+import { z } from 'zod';
+import { DEFAULT_TABLE_PREFIX, DEFAULT_VECTOR_DIMENSIONS, DEFAULT_CACHE_TTL } from './types.js';
+import { createSourceManager } from './federation/source-manager.js';
+import { createSyncEngine } from './federation/sync-engine.js';
+import { createCacheLayer } from './federation/cache-layer.js';
+import { createVectorAdapter } from './vectors/index.js';
+// Plugin state
+let sourceManager = null;
+let syncEngine = null;
+let cacheLayer = null;
+let vectorAdapter = null;
+let pluginConfig = null;
+/**
+ * Get source manager for code usage
+ */
+export function getSourceManager() {
+    if (!sourceManager) {
+        throw new Error('SQL plugin not initialized');
+    }
+    return sourceManager;
+}
+/**
+ * Get sync engine for code usage
+ */
+export function getSyncEngine() {
+    if (!syncEngine) {
+        throw new Error('SQL plugin not initialized');
+    }
+    return syncEngine;
+}
+/**
+ * Get vector adapter for code usage
+ */
+export function getVectorAdapter() {
+    return vectorAdapter;
+}
+/**
+ * LokiCMS SQL Plugin Definition
+ */
+const plugin = {
+    name: 'lokicms-sql',
+    version: '1.0.0',
+    description: 'Universal SQL adapter with multi-database support and data federation',
+    async register(api) {
+        pluginConfig = api.config.sql || {};
+        const tablePrefix = pluginConfig.tablePrefix ?? DEFAULT_TABLE_PREFIX;
+        api.logger.info('Initializing SQL plugin');
+        // Create source manager
+        sourceManager = createSourceManager(api.logger, tablePrefix);
+        // Set up primary if configured
+        if (pluginConfig.primary) {
+            try {
+                await sourceManager.setPrimary(pluginConfig.primary.provider, pluginConfig.primary.mode, pluginConfig.primary.connection);
+                // Create vector adapter if configured
+                const primary = sourceManager.getPrimary();
+                if (primary && pluginConfig.vectors) {
+                    vectorAdapter = createVectorAdapter(primary, api.logger, {
+                        tableName: `${tablePrefix}vectors`,
+                        dimensions: pluginConfig.vectors.dimensions ?? DEFAULT_VECTOR_DIMENSIONS,
+                    });
+                    await vectorAdapter.initialize(pluginConfig.vectors.dimensions ?? DEFAULT_VECTOR_DIMENSIONS);
+                }
+            }
+            catch (error) {
+                api.logger.error(`Failed to connect to primary: ${error}`);
+            }
+        }
+        // Add configured sources
+        if (pluginConfig.sources) {
+            for (const sourceConfig of pluginConfig.sources) {
+                try {
+                    await sourceManager.addSource(sourceConfig);
+                    if (sourceConfig.autoSync) {
+                        await sourceManager.connect(sourceConfig.name);
+                    }
+                }
+                catch (error) {
+                    api.logger.error(`Failed to add source ${sourceConfig.name}: ${error}`);
+                }
+            }
+        }
+        // Create sync engine (requires LokiJS db from services)
+        const lokiDb = api.services.db;
+        if (lokiDb) {
+            syncEngine = createSyncEngine(sourceManager, lokiDb, api.logger);
+            // Create cache layer
+            const cacheConfig = pluginConfig.cache ?? {
+                enabled: true,
+                ttlMinutes: DEFAULT_CACHE_TTL,
+            };
+            cacheLayer = createCacheLayer(lokiDb, cacheConfig, api.logger);
+            // Start auto-sync for enabled sources
+            if (pluginConfig.sources) {
+                for (const sourceConfig of pluginConfig.sources) {
+                    if (sourceConfig.autoSync) {
+                        syncEngine.startAutoSync(sourceConfig.name);
+                    }
+                }
+            }
+        }
+        // Register MCP tools
+        registerMcpTools(api);
+        api.logger.info('SQL plugin registered');
+    },
+};
+/**
+ * Register all 15 MCP tools
+ */
+function registerMcpTools(api) {
+    // ========================================================================
+    // Tool 1: sql_status
+    // ========================================================================
+    api.mcp.registerTool('sql_status', {
+        description: 'Get status of all SQL connections including primary, sources, vectors, and cache',
+        inputSchema: z.object({}),
+        handler: async () => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            const primary = sourceManager.getPrimary();
+            let primaryStatus = null;
+            if (primary) {
+                primaryStatus = await primary.getStatus();
+            }
+            const sourceStatuses = await sourceManager.getAllStatuses();
+            const sources = {};
+            for (const [name, status] of sourceStatuses) {
+                sources[name] = status;
+            }
+            return {
+                primary: primaryStatus,
+                sources,
+                vectors: vectorAdapter ? {
+                    supported: vectorAdapter.isSupported(),
+                    type: vectorAdapter.type,
+                } : null,
+                cache: cacheLayer ? cacheLayer.getStats() : null,
+                syncJobs: syncEngine ? syncEngine.getJobs().length : 0,
+            };
+        },
+    });
+    // ========================================================================
+    // Tool 2: sql_connect
+    // ========================================================================
+    api.mcp.registerTool('sql_connect', {
+        description: 'Connect to a configured data source',
+        inputSchema: z.object({
+            source: z.string().describe('Source name to connect to'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            try {
+                await sourceManager.connect(input.source);
+                const status = await sourceManager.getStatus(input.source);
+                return {
+                    success: true,
+                    source: input.source,
+                    status,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 3: sql_disconnect
+    // ========================================================================
+    api.mcp.registerTool('sql_disconnect', {
+        description: 'Disconnect from a data source',
+        inputSchema: z.object({
+            source: z.string().describe('Source name to disconnect from'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            try {
+                // Stop auto-sync if running
+                if (syncEngine) {
+                    syncEngine.stopAutoSync(input.source);
+                }
+                await sourceManager.disconnect(input.source);
+                return {
+                    success: true,
+                    source: input.source,
+                    message: `Disconnected from ${input.source}`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 4: sql_sources
+    // ========================================================================
+    api.mcp.registerTool('sql_sources', {
+        description: 'List all configured data sources',
+        inputSchema: z.object({}),
+        handler: async () => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            const sources = sourceManager.getAllSources();
+            return {
+                count: sources.length,
+                sources: sources.map((s) => ({
+                    name: s.name,
+                    provider: s.config.provider,
+                    mode: s.config.mode,
+                    status: s.status,
+                    tables: Object.keys(s.config.tables),
+                    autoSync: s.config.autoSync ?? false,
+                    lastConnected: s.lastConnected,
+                    error: s.error,
+                })),
+            };
+        },
+    });
+    // ========================================================================
+    // Tool 5: sql_import
+    // ========================================================================
+    api.mcp.registerTool('sql_import', {
+        description: 'Import data from a readonly source into LokiJS collections',
+        inputSchema: z.object({
+            source: z.string().describe('Source name to import from'),
+            table: z.string().optional().describe('Specific table to import (omit for all)'),
+            fullRefresh: z.boolean().optional().describe('Clear existing data before import'),
+        }),
+        handler: async (input) => {
+            if (!syncEngine) {
+                return { error: 'Sync engine not initialized' };
+            }
+            try {
+                const result = await syncEngine.import({
+                    source: input.source,
+                    table: input.table,
+                    fullRefresh: input.fullRefresh ?? false,
+                });
+                return {
+                    success: result.success,
+                    source: result.source,
+                    table: result.table,
+                    collection: result.collection,
+                    inserted: result.inserted,
+                    updated: result.updated,
+                    deleted: result.deleted,
+                    errors: result.errors,
+                    duration: `${result.duration}ms`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 6: sql_sync
+    // ========================================================================
+    api.mcp.registerTool('sql_sync', {
+        description: 'Sync data from all or specific source',
+        inputSchema: z.object({
+            source: z.string().optional().describe('Source to sync (omit for all)'),
+        }),
+        handler: async (input) => {
+            if (!syncEngine) {
+                return { error: 'Sync engine not initialized' };
+            }
+            try {
+                const results = input.source
+                    ? await syncEngine.sync(input.source)
+                    : await syncEngine.syncAll();
+                return {
+                    success: results.every((r) => r.success),
+                    synced: results.length,
+                    results: results.map((r) => ({
+                        source: r.source,
+                        table: r.table,
+                        collection: r.collection,
+                        inserted: r.inserted,
+                        updated: r.updated,
+                        errors: r.errors.length,
+                    })),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 7: sql_query
+    // ========================================================================
+    api.mcp.registerTool('sql_query', {
+        description: 'Execute a SQL query on primary or specified source',
+        inputSchema: z.object({
+            sql: z.string().describe('SQL query to execute'),
+            source: z.string().optional().describe('Source name (omit for primary)'),
+            params: z.array(z.unknown()).optional().describe('Query parameters'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            const provider = input.source
+                ? sourceManager.getProvider(input.source)
+                : sourceManager.getPrimary();
+            if (!provider) {
+                return { error: input.source ? `Source '${input.source}' not found` : 'No primary configured' };
+            }
+            if (!provider.isConnected()) {
+                return { error: 'Provider not connected' };
+            }
+            try {
+                const result = await provider.query(input.sql, input.params);
+                return {
+                    success: true,
+                    rowCount: result.rowCount,
+                    rows: result.rows.slice(0, 100), // Limit response size
+                    truncated: result.rowCount > 100,
+                    fields: result.fields,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 8: sql_search
+    // ========================================================================
+    api.mcp.registerTool('sql_search', {
+        description: 'Perform full-text search on a table',
+        inputSchema: z.object({
+            table: z.string().describe('Table to search'),
+            query: z.string().describe('Search query text'),
+            columns: z.array(z.string()).optional().describe('Columns to search'),
+            limit: z.number().optional().describe('Maximum results'),
+            source: z.string().optional().describe('Source name (omit for primary)'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            const provider = input.source
+                ? sourceManager.getProvider(input.source)
+                : sourceManager.getPrimary();
+            if (!provider) {
+                return { error: 'Provider not found' };
+            }
+            const caps = await provider.getCapabilities();
+            if (!caps.fullText) {
+                return { error: 'Full-text search not supported by this provider' };
+            }
+            const limit = input.limit ?? 20;
+            const columns = input.columns ?? ['*'];
+            const escapedTable = provider.escapeIdentifier(input.table);
+            let sql;
+            const params = [];
+            // Build provider-specific full-text query
+            if (provider.type === 'postgresql') {
+                // PostgreSQL tsvector search
+                const searchColumns = columns.join(' || \' \' || ');
+                sql = `SELECT * FROM ${escapedTable}
+               WHERE to_tsvector('english', ${searchColumns}) @@ plainto_tsquery('english', $1)
+               LIMIT $2`;
+                params.push(input.query, limit);
+            }
+            else if (provider.type === 'mysql' || provider.type === 'mariadb') {
+                // MySQL/MariaDB MATCH AGAINST
+                const searchColumns = columns.join(', ');
+                sql = `SELECT * FROM ${escapedTable}
+               WHERE MATCH(${searchColumns}) AGAINST(? IN NATURAL LANGUAGE MODE)
+               LIMIT ?`;
+                params.push(input.query, limit);
+            }
+            else {
+                // SQLite LIKE fallback
+                const likeConditions = columns.map((col) => `${provider.escapeIdentifier(col)} LIKE ?`);
+                sql = `SELECT * FROM ${escapedTable}
+               WHERE ${likeConditions.join(' OR ')}
+               LIMIT ?`;
+                for (const _ of columns) {
+                    params.push(`%${input.query}%`);
+                }
+                params.push(limit);
+            }
+            try {
+                const result = await provider.query(sql, params);
+                return {
+                    success: true,
+                    query: input.query,
+                    results: result.rows,
+                    count: result.rowCount,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 9: sql_vector_search
+    // ========================================================================
+    api.mcp.registerTool('sql_vector_search', {
+        description: 'Perform semantic vector search',
+        inputSchema: z.object({
+            vector: z.array(z.number()).describe('Query vector'),
+            collection: z.string().optional().describe('Collection to search'),
+            limit: z.number().optional().describe('Maximum results'),
+            minSimilarity: z.number().optional().describe('Minimum similarity threshold (0-1)'),
+        }),
+        handler: async (input) => {
+            if (!vectorAdapter) {
+                return { error: 'Vector adapter not initialized' };
+            }
+            if (!vectorAdapter.isSupported()) {
+                return { error: 'Vector search not supported by current provider' };
+            }
+            try {
+                const results = await vectorAdapter.search(input.vector, {
+                    collection: input.collection,
+                    limit: input.limit ?? 10,
+                    minSimilarity: input.minSimilarity ?? 0,
+                });
+                return {
+                    success: true,
+                    count: results.length,
+                    results: results.map((r) => ({
+                        id: r.id,
+                        entryId: r.entryId,
+                        collection: r.collection,
+                        similarity: r.similarity,
+                    })),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 10: sql_vector_index
+    // ========================================================================
+    api.mcp.registerTool('sql_vector_index', {
+        description: 'Store or manage vector indexes',
+        inputSchema: z.object({
+            action: z.enum(['store', 'delete', 'create_index', 'status']).describe('Action to perform'),
+            id: z.string().optional().describe('Vector ID (for store/delete)'),
+            entryId: z.string().optional().describe('Entry ID (for store)'),
+            collection: z.string().optional().describe('Collection name'),
+            vector: z.array(z.number()).optional().describe('Vector data (for store)'),
+            indexType: z.string().optional().describe('Index type (hnsw, ivfflat)'),
+        }),
+        handler: async (input) => {
+            if (!vectorAdapter) {
+                return { error: 'Vector adapter not initialized' };
+            }
+            try {
+                switch (input.action) {
+                    case 'store':
+                        if (!input.id || !input.entryId || !input.collection || !input.vector) {
+                            return { error: 'Missing required fields for store: id, entryId, collection, vector' };
+                        }
+                        await vectorAdapter.store({
+                            id: input.id,
+                            entryId: input.entryId,
+                            collection: input.collection,
+                            vector: input.vector,
+                            textHash: '',
+                        });
+                        return { success: true, action: 'stored', id: input.id };
+                    case 'delete':
+                        if (!input.id) {
+                            return { error: 'Missing id for delete' };
+                        }
+                        const deleted = await vectorAdapter.delete(input.id);
+                        return { success: deleted, action: 'deleted', id: input.id };
+                    case 'create_index':
+                        const indexed = await vectorAdapter.createIndex(input.indexType);
+                        return { success: indexed, action: 'create_index', indexType: input.indexType ?? 'default' };
+                    case 'status':
+                        const hasIndex = await vectorAdapter.hasIndex();
+                        const count = await vectorAdapter.count(input.collection);
+                        return {
+                            success: true,
+                            supported: vectorAdapter.isSupported(),
+                            type: vectorAdapter.type,
+                            hasIndex,
+                            vectorCount: count,
+                            collection: input.collection,
+                        };
+                }
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 11: sql_cache_status
+    // ========================================================================
+    api.mcp.registerTool('sql_cache_status', {
+        description: 'Get cache statistics',
+        inputSchema: z.object({}),
+        handler: async () => {
+            if (!cacheLayer) {
+                return { error: 'Cache not initialized' };
+            }
+            const stats = cacheLayer.getStats();
+            return {
+                enabled: stats.enabled,
+                entries: stats.entries,
+                size: `${Math.round(stats.size / 1024)}KB`,
+                hits: stats.hits,
+                misses: stats.misses,
+                hitRate: stats.hits + stats.misses > 0
+                    ? `${Math.round((stats.hits / (stats.hits + stats.misses)) * 100)}%`
+                    : 'N/A',
+                ttlMinutes: stats.ttlMinutes,
+            };
+        },
+    });
+    // ========================================================================
+    // Tool 12: sql_cache_clear
+    // ========================================================================
+    api.mcp.registerTool('sql_cache_clear', {
+        description: 'Clear cache entries',
+        inputSchema: z.object({
+            collection: z.string().optional().describe('Clear only specific collection'),
+        }),
+        handler: async (input) => {
+            if (!cacheLayer) {
+                return { error: 'Cache not initialized' };
+            }
+            if (input.collection) {
+                const cleared = cacheLayer.clearCollection(input.collection);
+                return { success: true, cleared, collection: input.collection };
+            }
+            else {
+                cacheLayer.clear();
+                return { success: true, message: 'All cache cleared' };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 13: sql_schema
+    // ========================================================================
+    api.mcp.registerTool('sql_schema', {
+        description: 'View database schema',
+        inputSchema: z.object({
+            source: z.string().optional().describe('Source name (omit for primary)'),
+            table: z.string().optional().describe('Specific table for details'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            const provider = input.source
+                ? sourceManager.getProvider(input.source)
+                : sourceManager.getPrimary();
+            if (!provider || !provider.isConnected()) {
+                return { error: 'Provider not connected' };
+            }
+            try {
+                if (input.table) {
+                    const tableInfo = await provider.getTableInfo(input.table);
+                    if (!tableInfo) {
+                        return { error: `Table '${input.table}' not found` };
+                    }
+                    return {
+                        success: true,
+                        table: tableInfo,
+                    };
+                }
+                else {
+                    const schema = await provider.getSchema();
+                    return {
+                        success: true,
+                        tables: schema.tables.map((t) => ({
+                            name: t.name,
+                            schema: t.schema,
+                            columns: t.columns.length,
+                            rowCount: t.rowCount,
+                        })),
+                        views: schema.views,
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    // ========================================================================
+    // Tool 14: sql_map_table
+    // ========================================================================
+    api.mcp.registerTool('sql_map_table', {
+        description: 'Map a database table to a LokiJS collection',
+        inputSchema: z.object({
+            source: z.string().describe('Source name'),
+            table: z.string().describe('Table name'),
+            collection: z.string().describe('Target LokiJS collection name'),
+            primaryKey: z.string().optional().describe('Primary key column'),
+            columns: z.array(z.string()).optional().describe('Columns to include'),
+            where: z.string().optional().describe('WHERE clause for filtering'),
+            syncInterval: z.number().optional().describe('Auto-sync interval in minutes'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            const source = sourceManager.getSource(input.source);
+            if (!source) {
+                return { error: `Source '${input.source}' not found` };
+            }
+            // Add table mapping to source config
+            source.config.tables[input.table] = {
+                collection: input.collection,
+                primaryKey: input.primaryKey,
+                columns: input.columns,
+                where: input.where,
+                syncInterval: input.syncInterval,
+            };
+            return {
+                success: true,
+                source: input.source,
+                table: input.table,
+                collection: input.collection,
+                mapping: source.config.tables[input.table],
+                message: `Mapped ${input.source}.${input.table} → ${input.collection}`,
+            };
+        },
+    });
+    // ========================================================================
+    // Tool 15: sql_configure
+    // ========================================================================
+    api.mcp.registerTool('sql_configure', {
+        description: 'Configure SQL plugin sources and settings',
+        inputSchema: z.object({
+            action: z.enum(['add_source', 'remove_source', 'set_primary', 'configure_cache', 'configure_vectors'])
+                .describe('Configuration action'),
+            // Source options
+            name: z.string().optional().describe('Source name'),
+            provider: z.enum(['postgresql', 'mysql', 'mariadb', 'sqlite']).optional().describe('Provider type'),
+            mode: z.enum(['readwrite', 'readonly']).optional().describe('Connection mode'),
+            connectionString: z.string().optional().describe('Connection string'),
+            host: z.string().optional().describe('Database host'),
+            port: z.number().optional().describe('Database port'),
+            database: z.string().optional().describe('Database name'),
+            user: z.string().optional().describe('Database user'),
+            password: z.string().optional().describe('Database password'),
+            // Cache options
+            cacheEnabled: z.boolean().optional().describe('Enable cache'),
+            cacheTtl: z.number().optional().describe('Cache TTL in minutes'),
+            // Vector options
+            vectorDimensions: z.number().optional().describe('Vector dimensions'),
+            vectorIndex: z.boolean().optional().describe('Enable vector indexing'),
+        }),
+        handler: async (input) => {
+            if (!sourceManager) {
+                return { error: 'SQL plugin not initialized' };
+            }
+            try {
+                switch (input.action) {
+                    case 'add_source':
+                        if (!input.name || !input.provider) {
+                            return { error: 'Missing required fields: name, provider' };
+                        }
+                        const sourceConfig = {
+                            name: input.name,
+                            provider: input.provider,
+                            mode: input.mode ?? 'readonly',
+                            connection: input.connectionString
+                                ? { connectionString: input.connectionString }
+                                : {
+                                    host: input.host ?? 'localhost',
+                                    port: input.port,
+                                    database: input.database ?? '',
+                                    user: input.user ?? '',
+                                    password: input.password ?? '',
+                                },
+                            tables: {},
+                            autoSync: false,
+                        };
+                        await sourceManager.addSource(sourceConfig);
+                        await sourceManager.connect(input.name);
+                        return {
+                            success: true,
+                            action: 'add_source',
+                            name: input.name,
+                            status: await sourceManager.getStatus(input.name),
+                        };
+                    case 'remove_source':
+                        if (!input.name) {
+                            return { error: 'Missing source name' };
+                        }
+                        await sourceManager.removeSource(input.name);
+                        return { success: true, action: 'remove_source', name: input.name };
+                    case 'set_primary':
+                        if (!input.provider) {
+                            return { error: 'Missing provider' };
+                        }
+                        await sourceManager.setPrimary(input.provider, input.mode ?? 'readwrite', input.connectionString
+                            ? { connectionString: input.connectionString }
+                            : {
+                                host: input.host ?? 'localhost',
+                                port: input.port,
+                                database: input.database ?? '',
+                                user: input.user ?? '',
+                                password: input.password ?? '',
+                            });
+                        const primary = sourceManager.getPrimary();
+                        return {
+                            success: true,
+                            action: 'set_primary',
+                            provider: input.provider,
+                            status: primary ? await primary.getStatus() : null,
+                        };
+                    case 'configure_cache':
+                        if (!cacheLayer) {
+                            return { error: 'Cache not initialized' };
+                        }
+                        if (input.cacheEnabled !== undefined) {
+                            cacheLayer.setEnabled(input.cacheEnabled);
+                        }
+                        return {
+                            success: true,
+                            action: 'configure_cache',
+                            stats: cacheLayer.getStats(),
+                        };
+                    case 'configure_vectors':
+                        if (!vectorAdapter) {
+                            return { error: 'Vector adapter not initialized' };
+                        }
+                        if (input.vectorIndex) {
+                            await vectorAdapter.createIndex();
+                        }
+                        return {
+                            success: true,
+                            action: 'configure_vectors',
+                            supported: vectorAdapter.isSupported(),
+                            hasIndex: await vectorAdapter.hasIndex(),
+                        };
+                    default:
+                        return { error: `Unknown action: ${input.action}` };
+                }
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+    api.logger.info('SQL plugin registered 15 MCP tools: sql_status, sql_connect, sql_disconnect, sql_sources, ' +
+        'sql_import, sql_sync, sql_query, sql_search, sql_vector_search, sql_vector_index, ' +
+        'sql_cache_status, sql_cache_clear, sql_schema, sql_map_table, sql_configure');
+}
+export default plugin;
+//# sourceMappingURL=plugin.js.map