mcp-db-analyzer 0.2.0

package/build/analyzers/relationships.js

@@ -0,0 +1,210 @@
+/**
+ * Table relationship analyzer.
+ *
+ * Queries foreign key constraints to build a dependency graph.
+ * Detects:
+ * - Orphan tables (no FK relationships at all)
+ * - Cascading delete chains (CASCADE rules that could cause unexpected data loss)
+ * - Highly connected tables (many FKs pointing in/out — central entities)
+ * - Missing reciprocal relationships
+ */
+import { query, getDriverType } from "../db.js";
+export async function analyzeTableRelationships(schema = "public") {
+    const driver = getDriverType();
+    if (driver === "sqlite") {
+        return analyzeSqliteRelationships();
+    }
+    if (driver === "mysql") {
+        return analyzeMysqlRelationships(schema);
+    }
+    return analyzePostgresRelationships(schema);
+}
+async function analyzePostgresRelationships(schema) {
+    // Get all tables
+    const tablesResult = await query(`SELECT table_name FROM information_schema.tables
+     WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+     ORDER BY table_name`, [schema]);
+    if (tablesResult.rows.length === 0) {
+        return "## Table Relationships\n\nNo tables found in schema.";
+    }
+    // Get all foreign keys
+    const fkResult = await query(`SELECT
+       kcu.table_name AS source_table,
+       kcu.column_name AS source_column,
+       ccu.table_name AS target_table,
+       ccu.column_name AS target_column,
+       tc.constraint_name,
+       rc.delete_rule AS on_delete,
+       rc.update_rule AS on_update
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     JOIN information_schema.constraint_column_usage ccu
+       ON ccu.constraint_name = tc.constraint_name
+       AND ccu.table_schema = tc.table_schema
+     JOIN information_schema.referential_constraints rc
+       ON rc.constraint_name = tc.constraint_name
+       AND rc.constraint_schema = tc.table_schema
+     WHERE tc.constraint_type = 'FOREIGN KEY'
+       AND tc.table_schema = $1
+     ORDER BY kcu.table_name, kcu.column_name`, [schema]);
+    return formatRelationshipReport(tablesResult.rows.map(r => r.table_name), fkResult.rows);
+}
+async function analyzeMysqlRelationships(schema) {
+    const tablesResult = await query(`SELECT TABLE_NAME AS table_name FROM information_schema.TABLES
+     WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE'
+     ORDER BY TABLE_NAME`, [schema]);
+    if (tablesResult.rows.length === 0) {
+        return "## Table Relationships\n\nNo tables found in schema.";
+    }
+    const fkResult = await query(`SELECT
+       kcu.TABLE_NAME AS source_table,
+       kcu.COLUMN_NAME AS source_column,
+       kcu.REFERENCED_TABLE_NAME AS target_table,
+       kcu.REFERENCED_COLUMN_NAME AS target_column,
+       kcu.CONSTRAINT_NAME AS constraint_name,
+       rc.DELETE_RULE AS on_delete,
+       rc.UPDATE_RULE AS on_update
+     FROM information_schema.KEY_COLUMN_USAGE kcu
+     JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+       ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+       AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
+     WHERE kcu.TABLE_SCHEMA = ?
+       AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+     ORDER BY kcu.TABLE_NAME, kcu.COLUMN_NAME`, [schema]);
+    return formatRelationshipReport(tablesResult.rows.map(r => r.table_name), fkResult.rows);
+}
+async function analyzeSqliteRelationships() {
+    // Get all tables
+    const tablesResult = await query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+    if (tablesResult.rows.length === 0) {
+        return "## Table Relationships\n\nNo tables found.";
+    }
+    // Get FK info per table
+    const fks = [];
+    for (const table of tablesResult.rows) {
+        const fkInfo = await query(`PRAGMA foreign_key_list('${table.name}')`);
+        for (const fk of fkInfo.rows) {
+            fks.push({
+                source_table: table.name,
+                source_column: fk.from,
+                target_table: fk.table,
+                target_column: fk.to,
+                constraint_name: `fk_${table.name}_${fk.from}`,
+                on_delete: fk.on_delete,
+                on_update: fk.on_update,
+            });
+        }
+    }
+    return formatRelationshipReport(tablesResult.rows.map(r => r.name), fks);
+}
+function formatRelationshipReport(allTables, foreignKeys) {
+    const lines = [];
+    lines.push("## Table Relationships\n");
+    // Build graph
+    const graph = new Map();
+    for (const t of allTables) {
+        graph.set(t, { name: t, outgoing: [], incoming: [] });
+    }
+    for (const fk of foreignKeys) {
+        const source = graph.get(fk.source_table);
+        const target = graph.get(fk.target_table);
+        if (source)
+            source.outgoing.push(fk);
+        if (target)
+            target.incoming.push(fk);
+    }
+    // Summary
+    lines.push(`**Tables**: ${allTables.length}`);
+    lines.push(`**Foreign Keys**: ${foreignKeys.length}`);
+    lines.push("");
+    // Relationship map
+    if (foreignKeys.length > 0) {
+        lines.push("### Foreign Key Map\n");
+        lines.push("| Source Table | Column | Target Table | Column | ON DELETE | ON UPDATE |");
+        lines.push("|-------------|--------|--------------|--------|-----------|-----------|");
+        for (const fk of foreignKeys) {
+            lines.push(`| ${fk.source_table} | ${fk.source_column} | ${fk.target_table} | ${fk.target_column} | ${fk.on_delete} | ${fk.on_update} |`);
+        }
+        lines.push("");
+    }
+    // Central entities (most connections)
+    const connectivity = allTables
+        .map(t => {
+        const node = graph.get(t);
+        return { name: t, total: node.outgoing.length + node.incoming.length, incoming: node.incoming.length, outgoing: node.outgoing.length };
+    })
+        .filter(t => t.total > 0)
+        .sort((a, b) => b.total - a.total);
+    if (connectivity.length > 0) {
+        lines.push("### Entity Connectivity\n");
+        lines.push("| Table | Incoming FKs | Outgoing FKs | Total |");
+        lines.push("|-------|-------------|-------------|-------|");
+        for (const c of connectivity) {
+            const marker = c.total >= 5 ? " **hub**" : "";
+            lines.push(`| ${c.name}${marker} | ${c.incoming} | ${c.outgoing} | ${c.total} |`);
+        }
+        lines.push("");
+    }
+    // Orphan tables (no FK relationships at all)
+    const orphans = allTables.filter(t => {
+        const node = graph.get(t);
+        return node.outgoing.length === 0 && node.incoming.length === 0;
+    });
+    if (orphans.length > 0) {
+        lines.push("### Orphan Tables (no FK relationships)\n");
+        for (const o of orphans) {
+            lines.push(`- \`${o}\``);
+        }
+        lines.push("");
+        lines.push("*Orphan tables may be lookup tables, denormalized tables, or tables missing FK constraints.*");
+        lines.push("");
+    }
+    // Cascading delete chains
+    const cascadeDeletes = foreignKeys.filter(fk => fk.on_delete === "CASCADE");
+    if (cascadeDeletes.length > 0) {
+        lines.push("### Cascading Delete Chains\n");
+        lines.push("Deleting a row from these parent tables will cascade-delete rows in child tables:\n");
+        // Group by target (parent) table
+        const cascadeByParent = new Map();
+        for (const fk of cascadeDeletes) {
+            const existing = cascadeByParent.get(fk.target_table) || [];
+            existing.push(fk);
+            cascadeByParent.set(fk.target_table, existing);
+        }
+        for (const [parent, fks] of cascadeByParent) {
+            const children = fks.map(f => f.source_table).join(", ");
+            lines.push(`- **${parent}** → cascades to: ${children}`);
+            // Check for deep chains (cascade through multiple levels)
+            for (const fk of fks) {
+                const grandchildren = cascadeDeletes.filter(gfk => gfk.target_table === fk.source_table);
+                if (grandchildren.length > 0) {
+                    const gcNames = grandchildren.map(g => g.source_table).join(", ");
+                    lines.push(`  - **${fk.source_table}** → further cascades to: ${gcNames}`);
+                }
+            }
+        }
+        lines.push("");
+        lines.push("**WARNING**: Cascading deletes can cause unexpected data loss. Ensure all CASCADE rules are intentional.\n");
+    }
+    // Recommendations
+    const issues = [];
+    if (orphans.length > 0 && orphans.length > allTables.length * 0.5) {
+        issues.push(`${orphans.length}/${allTables.length} tables have no FK relationships — consider adding foreign key constraints for data integrity`);
+    }
+    if (cascadeDeletes.length > 3) {
+        issues.push(`${cascadeDeletes.length} CASCADE DELETE rules — review each one to ensure intended behavior`);
+    }
+    const hubs = connectivity.filter(c => c.total >= 5);
+    if (hubs.length > 0) {
+        issues.push(`Hub tables (${hubs.map(h => h.name).join(", ")}) have 5+ FK connections — changes to these tables affect many others`);
+    }
+    if (issues.length > 0) {
+        lines.push("### Recommendations\n");
+        for (const issue of issues) {
+            lines.push(`- ${issue}`);
+        }
+    }
+    return lines.join("\n");
+}

package/build/analyzers/schema.js

@@ -0,0 +1,259 @@
+import { query, getDriverType } from "../db.js";
+/**
+ * List all user tables with row estimates and sizes.
+ */
+export async function listTables(schema = "public") {
+    const driver = getDriverType();
+    if (driver === "sqlite") {
+        return listTablesSqlite();
+    }
+    if (driver === "mysql") {
+        return listTablesMysql(schema);
+    }
+    const result = await query(`
+    SELECT
+      t.table_name,
+      t.table_schema,
+      COALESCE(s.n_live_tup, 0)::text AS row_estimate,
+      pg_size_pretty(pg_total_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name))) AS total_size
+    FROM information_schema.tables t
+    LEFT JOIN pg_stat_user_tables s
+      ON s.schemaname = t.table_schema AND s.relname = t.table_name
+    WHERE t.table_schema = $1
+      AND t.table_type = 'BASE TABLE'
+    ORDER BY COALESCE(s.n_live_tup, 0) DESC
+  `, [schema]);
+    return formatTableList(result.rows, schema);
+}
+async function listTablesMysql(schema) {
+    const result = await query(`
+    SELECT
+      TABLE_NAME AS table_name,
+      TABLE_SCHEMA AS table_schema,
+      CAST(TABLE_ROWS AS CHAR) AS row_estimate,
+      CONCAT(
+        ROUND((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2),
+        ' MB'
+      ) AS total_size
+    FROM information_schema.TABLES
+    WHERE TABLE_SCHEMA = ?
+      AND TABLE_TYPE = 'BASE TABLE'
+    ORDER BY TABLE_ROWS DESC
+  `, [schema]);
+    return formatTableList(result.rows, schema);
+}
+async function listTablesSqlite() {
+    const result = await query(`
+    SELECT name FROM sqlite_master
+    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `);
+    if (result.rows.length === 0) {
+        return `No tables found in database.`;
+    }
+    const lines = [`## Tables in schema 'main'\n`];
+    lines.push("| Table | Rows (est.) | Total Size |");
+    lines.push("|-------|-------------|------------|");
+    for (const row of result.rows) {
+        // SQLite doesn't have built-in row count or size — use count
+        const countResult = await query(`SELECT count(*) as cnt FROM "${row.name}"`);
+        const cnt = countResult.rows[0]?.cnt ?? 0;
+        lines.push(`| ${row.name} | ${cnt} | - |`);
+    }
+    return lines.join("\n");
+}
+function formatTableList(rows, schema) {
+    if (rows.length === 0) {
+        return `No tables found in schema '${schema}'.`;
+    }
+    const lines = [`## Tables in schema '${schema}'\n`];
+    lines.push("| Table | Rows (est.) | Total Size |");
+    lines.push("|-------|-------------|------------|");
+    for (const row of rows) {
+        lines.push(`| ${row.table_name} | ${row.row_estimate} | ${row.total_size} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Get detailed schema information for a specific table.
+ */
+export async function inspectTable(tableName, schema = "public") {
+    const driver = getDriverType();
+    if (driver === "sqlite") {
+        return inspectTableSqlite(tableName);
+    }
+    // Columns — information_schema works for both PG and MySQL
+    const colResult = await query(`
+    SELECT column_name, data_type, is_nullable, column_default,
+           character_maximum_length, ordinal_position
+    FROM information_schema.columns
+    WHERE table_schema = ${driver === "mysql" ? "?" : "$1"}
+      AND table_name = ${driver === "mysql" ? "?" : "$2"}
+    ORDER BY ordinal_position
+  `, [schema, tableName]);
+    if (colResult.rows.length === 0) {
+        return `Table '${schema}.${tableName}' not found.`;
+    }
+    const lines = [`## Table: ${schema}.${tableName}\n`];
+    // Stats — driver-specific
+    if (driver === "mysql") {
+        const statsResult = await query(`
+      SELECT
+        CAST(TABLE_ROWS AS CHAR) AS row_estimate,
+        CONCAT(ROUND((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2), ' MB') AS total_size,
+        CONCAT(ROUND(DATA_LENGTH / 1024 / 1024, 2), ' MB') AS table_size,
+        CONCAT(ROUND(INDEX_LENGTH / 1024 / 1024, 2), ' MB') AS index_size
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+    `, [schema, tableName]);
+        const stats = statsResult.rows[0];
+        if (stats) {
+            lines.push(`- **Rows (est.)**: ${stats.row_estimate}`);
+            lines.push(`- **Total size**: ${stats.total_size}`);
+            lines.push(`- **Table size**: ${stats.table_size}`);
+            lines.push(`- **Index size**: ${stats.index_size}`);
+            lines.push("");
+        }
+    }
+    else {
+        const statsResult = await query(`
+      SELECT
+        COALESCE(n_live_tup, 0)::text AS row_estimate,
+        pg_size_pretty(pg_total_relation_size(quote_ident($1) || '.' || quote_ident($2))) AS total_size,
+        pg_size_pretty(pg_table_size(quote_ident($1) || '.' || quote_ident($2))) AS table_size,
+        pg_size_pretty(pg_indexes_size(quote_ident($1) || '.' || quote_ident($2))) AS index_size
+      FROM pg_stat_user_tables
+      WHERE schemaname = $1 AND relname = $2
+    `, [schema, tableName]);
+        const stats = statsResult.rows[0];
+        if (stats) {
+            lines.push(`- **Rows (est.)**: ${stats.row_estimate}`);
+            lines.push(`- **Total size**: ${stats.total_size}`);
+            lines.push(`- **Table size**: ${stats.table_size}`);
+            lines.push(`- **Index size**: ${stats.index_size}`);
+            lines.push("");
+        }
+    }
+    // Columns
+    lines.push("### Columns\n");
+    lines.push("| # | Column | Type | Nullable | Default |");
+    lines.push("|---|--------|------|----------|---------|");
+    for (const col of colResult.rows) {
+        const type = col.character_maximum_length
+            ? `${col.data_type}(${col.character_maximum_length})`
+            : col.data_type;
+        lines.push(`| ${col.ordinal_position} | ${col.column_name} | ${type} | ${col.is_nullable} | ${col.column_default ?? "-"} |`);
+    }
+    // Constraints — information_schema works for both, but FK detection differs
+    if (driver === "mysql") {
+        const constraintResult = await query(`
+      SELECT
+        tc.CONSTRAINT_NAME AS constraint_name,
+        tc.CONSTRAINT_TYPE AS constraint_type,
+        kcu.COLUMN_NAME AS column_name,
+        kcu.REFERENCED_TABLE_NAME AS foreign_table_name,
+        kcu.REFERENCED_COLUMN_NAME AS foreign_column_name
+      FROM information_schema.TABLE_CONSTRAINTS tc
+      JOIN information_schema.KEY_COLUMN_USAGE kcu
+        ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+        AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+        AND tc.TABLE_NAME = kcu.TABLE_NAME
+      WHERE tc.TABLE_SCHEMA = ? AND tc.TABLE_NAME = ?
+      ORDER BY tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME
+    `, [schema, tableName]);
+        appendConstraints(constraintResult.rows, lines);
+    }
+    else {
+        const constraintResult = await query(`
+      SELECT
+        tc.constraint_name,
+        tc.constraint_type,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      LEFT JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name
+        AND tc.table_schema = ccu.table_schema
+        AND tc.constraint_type = 'FOREIGN KEY'
+      WHERE tc.table_schema = $1 AND tc.table_name = $2
+      ORDER BY tc.constraint_type, tc.constraint_name
+    `, [schema, tableName]);
+        appendConstraints(constraintResult.rows, lines);
+    }
+    return lines.join("\n");
+}
+async function inspectTableSqlite(tableName) {
+    const cols = await query(`PRAGMA table_info("${tableName}")`);
+    if (cols.rows.length === 0) {
+        return `Table '${tableName}' not found.`;
+    }
+    const lines = [`## Table: main.${tableName}\n`];
+    // Row count
+    const countResult = await query(`SELECT count(*) as cnt FROM "${tableName}"`);
+    lines.push(`- **Rows**: ${countResult.rows[0]?.cnt ?? 0}`);
+    lines.push("");
+    lines.push("### Columns\n");
+    lines.push("| # | Column | Type | Nullable | Default | PK |");
+    lines.push("|---|--------|------|----------|---------|-----|");
+    for (const col of cols.rows) {
+        lines.push(`| ${col.cid + 1} | ${col.name} | ${col.type || 'ANY'} | ${col.notnull ? 'NO' : 'YES'} | ${col.dflt_value ?? '-'} | ${col.pk ? 'YES' : '-'} |`);
+    }
+    // Foreign keys
+    const fks = await query(`PRAGMA foreign_key_list("${tableName}")`);
+    if (fks.rows.length > 0) {
+        lines.push("\n### Foreign Keys\n");
+        lines.push("| Column | References |");
+        lines.push("|--------|------------|");
+        for (const fk of fks.rows) {
+            lines.push(`| ${fk.from} | ${fk.table}(${fk.to}) |`);
+        }
+    }
+    // Indexes
+    const indexes = await query(`PRAGMA index_list("${tableName}")`);
+    if (indexes.rows.length > 0) {
+        lines.push("\n### Indexes\n");
+        lines.push("| Name | Unique | Columns |");
+        lines.push("|------|--------|---------|");
+        for (const idx of indexes.rows) {
+            const idxCols = await query(`PRAGMA index_info("${idx.name}")`);
+            const colNames = idxCols.rows.map(c => c.name).join(", ");
+            lines.push(`| ${idx.name} | ${idx.unique ? 'YES' : 'NO'} | ${colNames} |`);
+        }
+    }
+    return lines.join("\n");
+}
+function appendConstraints(rows, lines) {
+    const constraintMap = new Map();
+    for (const row of rows) {
+        let c = constraintMap.get(row.constraint_name);
+        if (!c) {
+            c = {
+                constraint_name: row.constraint_name,
+                constraint_type: row.constraint_type,
+                columns: [],
+                foreign_table: row.foreign_table_name,
+                foreign_columns: row.foreign_column_name ? [] : null,
+            };
+            constraintMap.set(row.constraint_name, c);
+        }
+        c.columns.push(row.column_name);
+        if (row.foreign_column_name) {
+            c.foreign_columns?.push(row.foreign_column_name);
+        }
+    }
+    if (constraintMap.size > 0) {
+        lines.push("\n### Constraints\n");
+        lines.push("| Name | Type | Columns | References |");
+        lines.push("|------|------|---------|------------|");
+        for (const c of constraintMap.values()) {
+            const ref = c.foreign_table
+                ? `${c.foreign_table}(${c.foreign_columns?.join(", ")})`
+                : "-";
+            lines.push(`| ${c.constraint_name} | ${c.constraint_type} | ${c.columns.join(", ")} | ${ref} |`);
+        }
+    }
+}

package/build/analyzers/slow-queries.js

@@ -0,0 +1,127 @@
+/**
+ * Slow query analyzer.
+ *
+ * Queries pg_stat_statements (if available) for the slowest queries
+ * and suggests optimization strategies.
+ */
+import { query, getDriverType } from "../db.js";
+export async function analyzeSlowQueries(schema, limit = 10) {
+    const driver = getDriverType();
+    if (driver === "sqlite") {
+        return "## Slow Query Analysis\n\nNot available for SQLite — no query statistics tracking.";
+    }
+    if (driver === "mysql") {
+        return analyzeMysqlSlowQueries(limit);
+    }
+    return analyzePostgresSlowQueries(schema, limit);
+}
+async function analyzePostgresSlowQueries(schema, limit) {
+    // Check if pg_stat_statements is available
+    try {
+        const extCheck = await query("SELECT extname FROM pg_extension WHERE extname = 'pg_stat_statements'");
+        if (extCheck.rows.length === 0) {
+            return [
+                "## Slow Query Analysis",
+                "",
+                "**pg_stat_statements extension not installed.**",
+                "",
+                "To enable slow query tracking:",
+                "```sql",
+                "CREATE EXTENSION pg_stat_statements;",
+                "```",
+                "",
+                "Also add to `postgresql.conf`:",
+                "```",
+                "shared_preload_libraries = 'pg_stat_statements'",
+                "pg_stat_statements.track = all",
+                "```",
+                "",
+                "Restart PostgreSQL and queries will be tracked automatically.",
+            ].join("\n");
+        }
+    }
+    catch {
+        return "## Slow Query Analysis\n\nUnable to check pg_stat_statements. Ensure the database user has permissions.";
+    }
+    try {
+        const result = await query(`SELECT
+        query,
+        calls,
+        total_exec_time,
+        mean_exec_time,
+        min_exec_time,
+        max_exec_time,
+        rows
+      FROM pg_stat_statements
+      WHERE query NOT LIKE '%pg_stat_statements%'
+        AND query NOT LIKE 'BEGIN%'
+        AND query NOT LIKE 'COMMIT%'
+        AND query NOT LIKE 'SET %'
+      ORDER BY mean_exec_time DESC
+      LIMIT $1`, [limit]);
+        if (result.rows.length === 0) {
+            return "## Slow Query Analysis\n\nNo query statistics found. Run some queries first.";
+        }
+        const sections = [];
+        sections.push("## Slow Query Analysis (by avg execution time)");
+        sections.push("");
+        sections.push("| # | Avg Time | Total Time | Calls | Avg Rows | Query |");
+        sections.push("|---|----------|------------|-------|----------|-------|");
+        for (let i = 0; i < result.rows.length; i++) {
+            const r = result.rows[i];
+            const avgMs = r.mean_exec_time.toFixed(1);
+            const totalMs = r.total_exec_time.toFixed(0);
+            const truncatedQuery = r.query.length > 80 ? r.query.slice(0, 77) + "..." : r.query;
+            const avgRows = Math.round(r.rows / Math.max(r.calls, 1));
+            sections.push(`| ${i + 1} | ${avgMs}ms | ${totalMs}ms | ${r.calls} | ${avgRows} | \`${truncatedQuery.replace(/\|/g, "\\|")}\` |`);
+        }
+        // Recommendations
+        sections.push("");
+        sections.push("### Recommendations");
+        const highCallSlowQueries = result.rows.filter((r) => r.calls > 100 && r.mean_exec_time > 100);
+        if (highCallSlowQueries.length > 0) {
+            sections.push(`- **${highCallSlowQueries.length} high-impact queries** — called >100 times with >100ms avg. Prioritize these for optimization.`);
+        }
+        const seqScanCandidates = result.rows.filter((r) => r.mean_exec_time > 50 && r.rows / Math.max(r.calls, 1) < 10);
+        if (seqScanCandidates.length > 0) {
+            sections.push(`- **${seqScanCandidates.length} queries returning few rows but slow** — likely missing indexes. Use \`explain_query\` to check.`);
+        }
+        return sections.join("\n");
+    }
+    catch (err) {
+        return `## Slow Query Analysis\n\nError querying pg_stat_statements: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+async function analyzeMysqlSlowQueries(limit) {
+    try {
+        const result = await query(`SELECT
+        DIGEST_TEXT,
+        COUNT_STAR,
+        SUM_TIMER_WAIT / 1000000000 as SUM_TIMER_WAIT,
+        AVG_TIMER_WAIT / 1000000000 as AVG_TIMER_WAIT,
+        SUM_ROWS_EXAMINED,
+        SUM_ROWS_SENT
+      FROM performance_schema.events_statements_summary_by_digest
+      WHERE DIGEST_TEXT IS NOT NULL
+        AND DIGEST_TEXT NOT LIKE '%performance_schema%'
+      ORDER BY AVG_TIMER_WAIT DESC
+      LIMIT ?`, [limit]);
+        if (result.rows.length === 0) {
+            return "## Slow Query Analysis\n\nNo query statistics found in performance_schema.";
+        }
+        const sections = [];
+        sections.push("## Slow Query Analysis (MySQL — by avg execution time)");
+        sections.push("");
+        sections.push("| # | Avg Time | Total Time | Calls | Query |");
+        sections.push("|---|----------|------------|-------|-------|");
+        for (let i = 0; i < result.rows.length; i++) {
+            const r = result.rows[i];
+            const truncated = r.DIGEST_TEXT.length > 80 ? r.DIGEST_TEXT.slice(0, 77) + "..." : r.DIGEST_TEXT;
+            sections.push(`| ${i + 1} | ${r.AVG_TIMER_WAIT.toFixed(1)}ms | ${r.SUM_TIMER_WAIT.toFixed(0)}ms | ${r.COUNT_STAR} | \`${truncated.replace(/\|/g, "\\|")}\` |`);
+        }
+        return sections.join("\n");
+    }
+    catch {
+        return "## Slow Query Analysis\n\nUnable to query performance_schema. Ensure it is enabled and the user has SELECT permission.";
+    }
+}