@adevguide/mcp-database-server 1.0.2 → 1.0.3

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import dotenv from "dotenv";
 import { parseArgs } from "util";
-import { readFileSync } from "fs";
+import { readFileSync, existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname2, join as join2 } from "path";
 
@@ -264,7 +264,34 @@ function findJoinPaths(tables, relationships, maxDepth = 3) {
 }
 
 // src/config.ts
+function findProjectRoot(startDir = process.cwd()) {
+  const projectMarkers = ["package.json", ".git", "tsconfig.json", "pyproject.toml", "Cargo.toml", "go.mod"];
+  let currentDir = resolve(startDir);
+  while (true) {
+    for (const marker of projectMarkers) {
+      if (existsSync(join(currentDir, marker))) {
+        return currentDir;
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
 function findConfigFile(fileName, startDir = process.cwd()) {
+  const projectRoot = findProjectRoot(startDir);
+  if (projectRoot) {
+    const configFromProjectRoot = findConfigFileFromDir(fileName, projectRoot);
+    if (configFromProjectRoot) {
+      return configFromProjectRoot;
+    }
+  }
+  return findConfigFileFromDir(fileName, startDir);
+}
+function findConfigFileFromDir(fileName, startDir) {
   let currentDir = resolve(startDir);
   while (true) {
     const configPath = join(currentDir, fileName);
@@ -336,17 +363,21 @@ import pg from "pg";
 import pino from "pino";
 var logger;
 function initLogger(level = "info", pretty = false) {
-  logger = pino({
-    level,
-    transport: pretty ? {
-      target: "pino-pretty",
-      options: {
-        colorize: true,
-        translateTime: "SYS:standard",
-        ignore: "pid,hostname"
-      }
-    } : void 0
-  });
+  logger = pino(
+    {
+      level,
+      transport: pretty ? {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname"
+        }
+      } : void 0
+    },
+    pino.destination({ dest: 2, sync: false })
+    // Write to stderr (fd 2) for MCP protocol compatibility
+  );
   return logger;
 }
 function getLogger() {
@@ -1607,18 +1638,370 @@ var SchemaCache = class {
   }
 };
 
+// src/query-optimizer.ts
+var QueryOptimizer = class {
+  slowQueryThresholdMs;
+  slowQueryAlerts = /* @__PURE__ */ new Map();
+  constructor(options = {
+    slowQueryThresholdMs: 1e3,
+    maxHistoryForAnalysis: 1e3,
+    enableAutoAnalysis: true
+  }) {
+    this.slowQueryThresholdMs = options.slowQueryThresholdMs;
+  }
+  /**
+   * Analyze query complexity and extract performance metrics
+   */
+  analyzeQueryComplexity(sql) {
+    const complexity = {
+      selectColumns: this.countSelectColumns(sql),
+      whereConditions: this.countWhereConditions(sql),
+      joinCount: this.countJoins(sql),
+      subqueryCount: this.countSubqueries(sql),
+      hasAggregations: /\b(COUNT|SUM|AVG|MIN|MAX)\s*\(/i.test(sql),
+      hasDistinct: /\bDISTINCT\b/i.test(sql),
+      hasOrderBy: /\bORDER\s+BY\b/i.test(sql),
+      hasGroupBy: /\bGROUP\s+BY\b/i.test(sql),
+      estimatedComplexity: "simple"
+    };
+    let score = 0;
+    score += complexity.selectColumns * 0.5;
+    score += complexity.whereConditions * 1;
+    score += complexity.joinCount * 2;
+    score += complexity.subqueryCount * 3;
+    score += complexity.hasAggregations ? 2 : 0;
+    score += complexity.hasDistinct ? 1 : 0;
+    score += complexity.hasOrderBy ? 1 : 0;
+    score += complexity.hasGroupBy ? 1 : 0;
+    if (score <= 3) complexity.estimatedComplexity = "simple";
+    else if (score <= 7) complexity.estimatedComplexity = "medium";
+    else if (score <= 12) complexity.estimatedComplexity = "complex";
+    else complexity.estimatedComplexity = "very_complex";
+    return complexity;
+  }
+  /**
+   * Generate index recommendations based on query history and schema
+   */
+  generateIndexRecommendations(queryHistory, schema) {
+    const recommendations = [];
+    const columnUsage = /* @__PURE__ */ new Map();
+    for (const entry of queryHistory) {
+      if (entry.error) continue;
+      const tables = entry.tables;
+      const whereMatch = entry.sql.match(/WHERE\s+(.+?)(?:\s+(GROUP|ORDER|LIMIT|$))/i);
+      if (whereMatch) {
+        const whereClause = whereMatch[1];
+        const columns = this.extractColumnsFromCondition(whereClause, tables, schema);
+        for (const col of columns) {
+          const key = `${col.table}.${col.column}`;
+          const existing = columnUsage.get(key) || { table: col.table, usage: 0, inWhere: false, inJoin: false };
+          existing.usage++;
+          existing.inWhere = true;
+          columnUsage.set(key, existing);
+        }
+      }
+      const joinMatches = entry.sql.match(/JOIN\s+\w+\s+ON\s+(.+?)(?:\s+(WHERE|GROUP|ORDER|LIMIT|$))/gi);
+      if (joinMatches) {
+        for (const joinMatch of joinMatches) {
+          const joinClause = joinMatch.replace(/JOIN\s+\w+\s+ON\s+/i, "");
+          const columns = this.extractColumnsFromCondition(joinClause, tables, schema);
+          for (const col of columns) {
+            const key = `${col.table}.${col.column}`;
+            const existing = columnUsage.get(key) || { table: col.table, usage: 0, inWhere: false, inJoin: false };
+            existing.usage++;
+            existing.inJoin = true;
+            columnUsage.set(key, existing);
+          }
+        }
+      }
+    }
+    for (const [key, usage] of columnUsage) {
+      if (usage.usage < 3) continue;
+      const [tableName, columnName] = key.split(".");
+      const table = this.findTableInSchema(schema, tableName);
+      if (!table) continue;
+      const existingIndex = table.indexes.find(
+        (idx) => idx.columns.includes(columnName) && !idx.isPrimary
+      );
+      if (existingIndex) continue;
+      const recommendation = {
+        table: tableName,
+        columns: [columnName],
+        type: "single",
+        reason: `Column ${columnName} is frequently used in ${usage.inWhere ? "WHERE" : ""}${usage.inWhere && usage.inJoin ? " and " : ""}${usage.inJoin ? "JOIN" : ""} conditions`,
+        impact: usage.usage > 10 ? "high" : usage.usage > 5 ? "medium" : "low"
+      };
+      recommendations.push(recommendation);
+    }
+    return recommendations.sort((a, b) => {
+      const impactOrder = { high: 3, medium: 2, low: 1 };
+      return impactOrder[b.impact] - impactOrder[a.impact];
+    });
+  }
+  /**
+   * Profile query performance using EXPLAIN plan
+   */
+  async profileQueryPerformance(_dbId, sql, explainResult, executionTimeMs, rowCount) {
+    const bottlenecks = [];
+    const recommendations = [];
+    if (explainResult.plan) {
+      bottlenecks.push(...this.analyzeExplainPlan(explainResult.plan));
+    }
+    if (executionTimeMs > this.slowQueryThresholdMs) {
+      bottlenecks.push({
+        type: "table_scan",
+        severity: executionTimeMs > this.slowQueryThresholdMs * 5 ? "critical" : "high",
+        description: `Query execution time (${executionTimeMs}ms) exceeds threshold (${this.slowQueryThresholdMs}ms)`,
+        estimatedCost: executionTimeMs
+      });
+    }
+    for (const bottleneck of bottlenecks) {
+      switch (bottleneck.type) {
+        case "table_scan":
+          recommendations.push({
+            type: "add_index",
+            description: `Consider adding an index on ${bottleneck.table || "frequently queried columns"}`,
+            impact: "high",
+            effort: "medium"
+          });
+          break;
+        case "join":
+          recommendations.push({
+            type: "optimize_join",
+            description: "Review JOIN conditions and ensure proper indexing on join columns",
+            impact: "high",
+            effort: "medium"
+          });
+          break;
+        case "sort":
+          recommendations.push({
+            type: "add_index",
+            description: "Consider adding an index to avoid sorting operations",
+            impact: "medium",
+            effort: "medium"
+          });
+          break;
+      }
+    }
+    let score = 100;
+    for (const bottleneck of bottlenecks) {
+      const severityPenalty = { critical: 30, high: 20, medium: 10, low: 5 };
+      score -= severityPenalty[bottleneck.severity];
+    }
+    score = Math.max(0, Math.min(100, score));
+    return {
+      queryId: this.generateQueryId(sql),
+      sql,
+      executionTimeMs,
+      rowCount,
+      bottlenecks,
+      recommendations,
+      overallScore: score
+    };
+  }
+  /**
+   * Detect and alert on slow queries
+   */
+  detectSlowQueries(queryHistory, dbId) {
+    for (const entry of queryHistory) {
+      if (entry.executionTimeMs > this.slowQueryThresholdMs) {
+        const queryId = this.generateQueryId(entry.sql);
+        const existingAlerts = this.slowQueryAlerts.get(dbId) || [];
+        const existingAlert = existingAlerts.find((a) => a.queryId === queryId);
+        if (existingAlert) {
+          existingAlert.frequency++;
+          existingAlert.timestamp = entry.timestamp;
+          if (entry.executionTimeMs > existingAlert.executionTimeMs) {
+            existingAlert.executionTimeMs = entry.executionTimeMs;
+          }
+        } else {
+          const alert = {
+            dbId,
+            queryId,
+            sql: entry.sql,
+            executionTimeMs: entry.executionTimeMs,
+            thresholdMs: this.slowQueryThresholdMs,
+            timestamp: entry.timestamp,
+            frequency: 1,
+            recommendations: []
+          };
+          existingAlerts.push(alert);
+        }
+        this.slowQueryAlerts.set(dbId, existingAlerts);
+      }
+    }
+    return this.slowQueryAlerts.get(dbId) || [];
+  }
+  /**
+   * Suggest optimized versions of queries
+   */
+  suggestQueryRewrites(sql, schema) {
+    const optimizations = [];
+    let optimizedQuery = sql;
+    let performanceGain = 0;
+    if (/\bDISTINCT\b/i.test(sql) && this.canRemoveDistinct(sql, schema)) {
+      optimizedQuery = optimizedQuery.replace(/\bDISTINCT\b/i, "");
+      optimizations.push("Removed unnecessary DISTINCT clause");
+      performanceGain += 15;
+    }
+    if (!/\bLIMIT\b/i.test(sql) && !/\bCOUNT\b/i.test(sql)) {
+      optimizedQuery += " LIMIT 1000";
+      optimizations.push("Added LIMIT clause to prevent large result sets");
+      performanceGain += 10;
+    }
+    if (/\bSELECT\s+\*\s+FROM\b/i.test(sql)) {
+      optimizations.push("Consider selecting only required columns instead of SELECT *");
+      performanceGain += 5;
+    }
+    const tables = extractTableNames(sql);
+    for (const table of tables) {
+      const tableMeta = this.findTableInSchema(schema, table);
+      if (tableMeta && !/\bWHERE\b/i.test(sql)) {
+        optimizations.push(`Consider adding WHERE clause for table ${table} to reduce data scanned`);
+        performanceGain += 20;
+      }
+    }
+    return {
+      originalQuery: sql,
+      optimizedQuery,
+      improvements: optimizations,
+      performanceGain: Math.min(100, performanceGain),
+      confidence: optimizations.length > 2 ? "high" : optimizations.length > 0 ? "medium" : "low"
+    };
+  }
+  /**
+   * Get performance analytics across all queries
+   */
+  getPerformanceAnalytics(queryHistory) {
+    const analytics = {
+      totalQueries: queryHistory.length,
+      slowQueries: queryHistory.filter((q) => q.executionTimeMs > this.slowQueryThresholdMs).length,
+      avgExecutionTime: 0,
+      p95ExecutionTime: 0,
+      errorRate: 0,
+      mostFrequentTables: [],
+      performanceTrend: "stable"
+    };
+    if (queryHistory.length === 0) return analytics;
+    const executionTimes = queryHistory.map((q) => q.executionTimeMs).sort((a, b) => a - b);
+    analytics.avgExecutionTime = executionTimes.reduce((a, b) => a + b, 0) / executionTimes.length;
+    analytics.p95ExecutionTime = executionTimes[Math.floor(executionTimes.length * 0.95)];
+    analytics.errorRate = queryHistory.filter((q) => q.error).length / queryHistory.length * 100;
+    const tableUsage = /* @__PURE__ */ new Map();
+    for (const query of queryHistory) {
+      for (const table of query.tables) {
+        tableUsage.set(table, (tableUsage.get(table) || 0) + 1);
+      }
+    }
+    analytics.mostFrequentTables = Array.from(tableUsage.entries()).map(([table, count]) => ({ table, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const midpoint = Math.floor(queryHistory.length / 2);
+    const recentAvg = executionTimes.slice(midpoint).reduce((a, b) => a + b, 0) / (executionTimes.length - midpoint);
+    const olderAvg = executionTimes.slice(0, midpoint).reduce((a, b) => a + b, 0) / midpoint;
+    if (recentAvg < olderAvg * 0.8) analytics.performanceTrend = "improving";
+    else if (recentAvg > olderAvg * 1.2) analytics.performanceTrend = "degrading";
+    return analytics;
+  }
+  // Helper methods
+  countSelectColumns(sql) {
+    const selectMatch = sql.match(/SELECT\s+(.+?)\s+FROM/i);
+    if (!selectMatch) return 0;
+    const selectClause = selectMatch[1];
+    if (selectClause.includes("*")) return 1;
+    return (selectClause.match(/,/g) || []).length + 1;
+  }
+  countWhereConditions(sql) {
+    const whereMatch = sql.match(/WHERE\s+(.+?)(?:\s+(GROUP|ORDER|LIMIT|$))/i);
+    if (!whereMatch) return 0;
+    const whereClause = whereMatch[1];
+    return (whereClause.match(/\bAND\b/gi) || []).length + 1;
+  }
+  countJoins(sql) {
+    return (sql.match(/\bJOIN\b/gi) || []).length;
+  }
+  countSubqueries(sql) {
+    return (sql.match(/\(\s*SELECT/gi) || []).length;
+  }
+  extractColumnsFromCondition(condition, tables, schema) {
+    const columns = [];
+    const columnMatches = condition.match(/\b(\w+\.)?(\w+)\b/g) || [];
+    for (const match of columnMatches) {
+      if (match.includes(".")) {
+        const [table, column] = match.split(".");
+        if (tables.includes(table)) {
+          columns.push({ table, column });
+        }
+      } else {
+        const column = match;
+        for (const table of tables) {
+          const tableMeta = this.findTableInSchema(schema, table);
+          if (tableMeta?.columns.some((col) => col.name === column)) {
+            columns.push({ table, column });
+            break;
+          }
+        }
+      }
+    }
+    return columns;
+  }
+  analyzeExplainPlan(plan) {
+    const bottlenecks = [];
+    const planStr = JSON.stringify(plan).toLowerCase();
+    if (planStr.includes("table scan") || planStr.includes("seq scan")) {
+      bottlenecks.push({
+        type: "table_scan",
+        severity: "high",
+        description: "Full table scan detected - consider adding indexes",
+        estimatedCost: 100
+      });
+    }
+    if (planStr.includes("sort") && !planStr.includes("index")) {
+      bottlenecks.push({
+        type: "sort",
+        severity: "medium",
+        description: "In-memory sort operation - consider indexed ORDER BY",
+        estimatedCost: 50
+      });
+    }
+    return bottlenecks;
+  }
+  canRemoveDistinct(sql, _schema) {
+    return /\bGROUP\s+BY\b/i.test(sql) || /\bPRIMARY\s+KEY\b/i.test(sql);
+  }
+  findTableInSchema(schema, tableName) {
+    for (const schemaMeta of schema.schemas) {
+      const table = schemaMeta.tables.find((t) => t.name === tableName);
+      if (table) return table;
+    }
+    return null;
+  }
+  generateQueryId(sql) {
+    let hash = 0;
+    for (let i = 0; i < sql.length; i++) {
+      const char = sql.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+};
+
 // src/query-tracker.ts
 var QueryTracker = class {
   history = /* @__PURE__ */ new Map();
   maxHistoryPerDb = 100;
-  track(dbId, sql, executionTimeMs, rowCount, error) {
+  optimizer = new QueryOptimizer();
+  track(dbId, sql, executionTimeMs, rowCount, error, explainPlan) {
+    const complexity = this.optimizer.analyzeQueryComplexity(sql);
     const entry = {
       timestamp: /* @__PURE__ */ new Date(),
       sql,
       tables: extractTableNames(sql),
       executionTimeMs,
       rowCount,
-      error
+      error,
+      explainPlan,
+      queryComplexity: complexity,
+      performanceScore: this.calculatePerformanceScore(executionTimeMs, complexity)
     };
     if (!this.history.has(dbId)) {
       this.history.set(dbId, []);
@@ -1642,24 +2025,59 @@ var QueryTracker = class {
       totalQueries: dbHistory.length,
       avgExecutionTime: 0,
       errorCount: 0,
-      tableUsage: {}
+      tableUsage: {},
+      performanceMetrics: {
+        avgScore: 0,
+        slowQueryCount: 0,
+        complexityDistribution: {}
+      }
     };
     if (dbHistory.length === 0) {
       return stats;
     }
     let totalTime = 0;
+    let totalScore = 0;
     for (const entry of dbHistory) {
       totalTime += entry.executionTimeMs;
       if (entry.error) {
         stats.errorCount++;
       }
+      if (entry.performanceScore !== void 0) {
+        totalScore += entry.performanceScore;
+      }
+      if (entry.executionTimeMs > 1e3) {
+        stats.performanceMetrics.slowQueryCount++;
+      }
+      if (entry.queryComplexity) {
+        const complexity = entry.queryComplexity.estimatedComplexity;
+        stats.performanceMetrics.complexityDistribution[complexity] = (stats.performanceMetrics.complexityDistribution[complexity] || 0) + 1;
+      }
       for (const table of entry.tables) {
         stats.tableUsage[table] = (stats.tableUsage[table] || 0) + 1;
       }
     }
     stats.avgExecutionTime = totalTime / dbHistory.length;
+    stats.performanceMetrics.avgScore = totalScore / dbHistory.length;
     return stats;
   }
+  getPerformanceAnalytics(dbId) {
+    const history = this.getHistory(dbId);
+    return this.optimizer.getPerformanceAnalytics(history);
+  }
+  getIndexRecommendations(dbId, schema) {
+    const history = this.getHistory(dbId);
+    return this.optimizer.generateIndexRecommendations(history, schema);
+  }
+  getSlowQueryAlerts(dbId) {
+    const history = this.getHistory(dbId);
+    return this.optimizer.detectSlowQueries(history, dbId);
+  }
+  suggestQueryRewrite(sql, schema) {
+    return this.optimizer.suggestQueryRewrites(sql, schema);
+  }
+  async profileQueryPerformance(dbId, sql, explainResult, executionTimeMs, rowCount) {
+    return this.optimizer.profileQueryPerformance(dbId, sql, explainResult, executionTimeMs, rowCount);
+  }
   clear(dbId) {
     if (dbId) {
       this.history.delete(dbId);
@@ -1667,6 +2085,20 @@ var QueryTracker = class {
       this.history.clear();
     }
   }
+  calculatePerformanceScore(executionTimeMs, complexity) {
+    let score = 100;
+    if (executionTimeMs > 5e3) score -= 40;
+    else if (executionTimeMs > 1e3) score -= 20;
+    else if (executionTimeMs > 100) score -= 10;
+    const complexityPenalty = {
+      simple: 0,
+      medium: 5,
+      complex: 15,
+      very_complex: 25
+    };
+    score -= complexityPenalty[complexity.estimatedComplexity];
+    return Math.max(0, Math.min(100, score));
+  }
 };
 
 // src/database-manager.ts
@@ -1794,7 +2226,15 @@ var DatabaseManager = class {
     const adapter = this.getAdapter(dbId);
     try {
       const result = await adapter.query(sql, params, timeoutMs);
-      this.queryTracker.track(dbId, sql, result.executionTimeMs, result.rowCount);
+      let explainPlan;
+      if (!isWriteOperation(sql)) {
+        try {
+          explainPlan = await adapter.explain(sql, params);
+        } catch (_explainError) {
+          this.logger.debug({ dbId, sql }, "EXPLAIN failed, continuing without performance analysis");
+        }
+      }
+      this.queryTracker.track(dbId, sql, result.executionTimeMs, result.rowCount, void 0, explainPlan);
       return result;
     } catch (error) {
       this.queryTracker.track(dbId, sql, 0, 0, error.message);
@@ -1823,6 +2263,29 @@ var DatabaseManager = class {
   getQueryHistory(dbId, limit) {
     return this.queryTracker.getHistory(dbId, limit);
   }
+  getPerformanceAnalytics(dbId) {
+    return this.queryTracker.getPerformanceAnalytics(dbId);
+  }
+  async getIndexRecommendations(dbId) {
+    const schema = await this.getSchema(dbId);
+    return this.queryTracker.getIndexRecommendations(dbId, schema);
+  }
+  getSlowQueryAlerts(dbId) {
+    return this.queryTracker.getSlowQueryAlerts(dbId);
+  }
+  async suggestQueryRewrite(dbId, sql) {
+    const schema = await this.getSchema(dbId);
+    return this.queryTracker.suggestQueryRewrite(sql, schema);
+  }
+  async profileQueryPerformance(dbId, sql, params = []) {
+    await this.ensureConnected(dbId);
+    const adapter = this.getAdapter(dbId);
+    const startTime = Date.now();
+    const result = await adapter.query(sql, params);
+    const executionTimeMs = Date.now() - startTime;
+    const explainResult = await adapter.explain(sql, params);
+    return this.queryTracker.profileQueryPerformance(dbId, sql, explainResult, executionTimeMs, result.rowCount);
+  }
 };
 
 // src/mcp-server.ts
@@ -1832,7 +2295,8 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
   ListResourcesRequestSchema,
-  ReadResourceRequestSchema
+  ReadResourceRequestSchema,
+  InitializeRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 var MCPServer = class {
   constructor(_dbManager, _config) {
@@ -1855,6 +2319,21 @@ var MCPServer = class {
   server;
   logger = getLogger();
   setupHandlers() {
+    this.server.setRequestHandler(InitializeRequestSchema, async (request) => {
+      const { protocolVersion } = request.params;
+      this.logger.info({ protocolVersion }, "MCP server initializing");
+      return {
+        protocolVersion,
+        capabilities: {
+          tools: {},
+          resources: {}
+        },
+        serverInfo: {
+          name: "mcp-database-server",
+          version: "1.0.0"
+        }
+      };
+    });
     this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
       tools: [
         {
@@ -2034,6 +2513,89 @@ var MCPServer = class {
               }
             }
           }
+        },
+        {
+          name: "analyze_performance",
+          description: "Get detailed performance analytics for a database",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID to analyze"
+              }
+            },
+            required: ["dbId"]
+          }
+        },
+        {
+          name: "suggest_indexes",
+          description: "Analyze query patterns and suggest optimal indexes",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID to analyze"
+              }
+            },
+            required: ["dbId"]
+          }
+        },
+        {
+          name: "detect_slow_queries",
+          description: "Identify and alert on slow-running queries",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID to analyze"
+              }
+            },
+            required: ["dbId"]
+          }
+        },
+        {
+          name: "rewrite_query",
+          description: "Suggest optimized versions of SQL queries",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID"
+              },
+              sql: {
+                type: "string",
+                description: "SQL query to optimize"
+              }
+            },
+            required: ["dbId", "sql"]
+          }
+        },
+        {
+          name: "profile_query",
+          description: "Profile query performance with detailed analysis",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dbId: {
+                type: "string",
+                description: "Database ID"
+              },
+              sql: {
+                type: "string",
+                description: "SQL query to profile"
+              },
+              params: {
+                type: "array",
+                description: "Query parameters",
+                items: {}
+              }
+            },
+            required: ["dbId", "sql"]
+          }
         }
       ]
     }));
@@ -2059,6 +2621,16 @@ var MCPServer = class {
             return await this.handleCacheStatus(args);
           case "health_check":
             return await this.handleHealthCheck(args);
+          case "analyze_performance":
+            return await this.handleAnalyzePerformance(args);
+          case "suggest_indexes":
+            return await this.handleSuggestIndexes(args);
+          case "detect_slow_queries":
+            return await this.handleDetectSlowQueries(args);
+          case "rewrite_query":
+            return await this.handleRewriteQuery(args);
+          case "profile_query":
+            return await this.handleProfileQuery(args);
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -2294,9 +2866,67 @@ var MCPServer = class {
       ]
     };
   }
+  async handleAnalyzePerformance(args) {
+    const analytics = this._dbManager.getPerformanceAnalytics(args.dbId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(analytics, null, 2)
+        }
+      ]
+    };
+  }
+  async handleSuggestIndexes(args) {
+    const recommendations = await this._dbManager.getIndexRecommendations(args.dbId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(recommendations, null, 2)
+        }
+      ]
+    };
+  }
+  async handleDetectSlowQueries(args) {
+    const alerts = this._dbManager.getSlowQueryAlerts(args.dbId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(alerts, null, 2)
+        }
+      ]
+    };
+  }
+  async handleRewriteQuery(args) {
+    const suggestion = await this._dbManager.suggestQueryRewrite(args.dbId, args.sql);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(suggestion, null, 2)
+        }
+      ]
+    };
+  }
+  async handleProfileQuery(args) {
+    const profile = await this._dbManager.profileQueryPerformance(args.dbId, args.sql, args.params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(profile, null, 2)
+        }
+      ]
+    };
+  }
   async start() {
+    console.error("Starting MCP server...");
     const transport = new StdioServerTransport();
+    console.error("Created transport, connecting...");
     await this.server.connect(transport);
+    console.error("MCP server connected and started");
     this.logger.info("MCP server started");
   }
 };
@@ -2315,8 +2945,7 @@ async function main() {
       options: {
         config: {
           type: "string",
-          short: "c",
-          default: "./.mcp-database-server.config"
+          short: "c"
         },
         help: {
           type: "boolean",
@@ -2340,7 +2969,7 @@ Usage:
   mcp-database-server [options]
 
 Options:
-  -c, --config <path>  Path to configuration file (default: ./.mcp-database-server.config)
+  -c, --config <path>  Path to configuration file (if not specified, searches for .mcp-database-server.config from project root upwards)
   -h, --help          Show this help message
   -v, --version       Show version number
 
@@ -2358,13 +2987,19 @@ Examples:
       `);
       process.exit(0);
     }
-    let configPath = values.config;
-    if (configPath === "./.mcp-database-server.config") {
+    let configPath;
+    if (values.config) {
+      configPath = values.config;
+      if (!existsSync2(configPath)) {
+        console.error(`Error: Specified config file ${configPath} not found`);
+        process.exit(1);
+      }
+    } else {
       const foundPath = findConfigFile(".mcp-database-server.config");
       if (foundPath) {
         configPath = foundPath;
       } else {
-        console.error("Error: Config file .mcp-database-server.config not found");
+        console.error("Error: No config file specified, and .mcp-database-server.config not found");
         console.error("Searched in current directory and all parent directories");
         console.error("\nTo create a config file:");
         console.error("  cp mcp-database-server.config.example .mcp-database-server.config");