postgres-scout-mcp 1.0.0

package/dist/tools/database.js

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { ensureDatabaseExists, executeInternalQuery, getCurrentDatabaseName } from '../utils/database.js';
+const ListDatabasesSchema = z.object({});
+const GetDatabaseStatsSchema = z.object({
+    database: z.string().optional()
+});
+export async function listDatabases(connection, logger, args) {
+    logger.info('listDatabases', 'Listing all databases');
+    const query = `
+    SELECT
+      d.datname as name,
+      pg_catalog.pg_get_userbyid(d.datdba) as owner,
+      pg_catalog.pg_encoding_to_char(d.encoding) as encoding,
+      pg_catalog.pg_database_size(d.datname) as size_bytes,
+      (SELECT COUNT(*) FROM pg_catalog.pg_stat_activity WHERE datname = d.datname) as connections
+    FROM pg_catalog.pg_database d
+    WHERE d.datistemplate = false
+    ORDER BY d.datname;
+  `;
+    const result = await executeInternalQuery(connection, logger, { query });
+    return {
+        databases: result.rows.map(row => ({
+            name: row.name,
+            owner: row.owner,
+            encoding: row.encoding,
+            sizeBytes: parseInt(row.size_bytes, 10),
+            sizeMB: (parseInt(row.size_bytes, 10) / 1024 / 1024).toFixed(2),
+            connections: parseInt(row.connections, 10)
+        }))
+    };
+}
+export async function getDatabaseStats(connection, logger, args) {
+    const currentDatabase = await getCurrentDatabaseName(connection, logger);
+    const requestedDatabase = args.database;
+    if (requestedDatabase) {
+        await ensureDatabaseExists(connection, logger, requestedDatabase);
+        if (requestedDatabase !== currentDatabase) {
+            throw new Error(`Connected to "${currentDatabase}". Reconnect to "${requestedDatabase}" to fetch its stats.`);
+        }
+    }
+    logger.info('getDatabaseStats', 'Getting database statistics', { database: currentDatabase });
+    const queries = await Promise.all([
+        getSizeStats(connection, logger, currentDatabase),
+        getObjectCounts(connection, logger),
+        getConnectionStats(connection, logger),
+        getCacheStats(connection, logger),
+        getTupleStats(connection, logger)
+    ]);
+    const [sizeStats, objectCounts, connectionStats, cacheStats, tupleStats] = queries;
+    return {
+        database: currentDatabase,
+        size: sizeStats.size,
+        tables: objectCounts.tables,
+        indexes: objectCounts.indexes,
+        sequences: objectCounts.sequences,
+        views: objectCounts.views,
+        functions: objectCounts.functions,
+        activeConnections: connectionStats.active,
+        maxConnections: connectionStats.max,
+        cacheHitRatio: cacheStats.ratio,
+        transactionRate: cacheStats.transactionRate,
+        tupleStats: tupleStats
+    };
+}
+async function getSizeStats(connection, logger, database) {
+    const query = `SELECT pg_size_pretty(pg_database_size(current_database())) as size`;
+    const result = await executeInternalQuery(connection, logger, { query });
+    return { size: result.rows[0]?.size || '0' };
+}
+async function getObjectCounts(connection, logger) {
+    const query = `
+    SELECT
+      (SELECT COUNT(*) FROM pg_catalog.pg_class WHERE relkind = 'r') as tables,
+      (SELECT COUNT(*) FROM pg_catalog.pg_class WHERE relkind = 'i') as indexes,
+      (SELECT COUNT(*) FROM pg_catalog.pg_class WHERE relkind = 'S') as sequences,
+      (SELECT COUNT(*) FROM pg_catalog.pg_class WHERE relkind = 'v') as views,
+      (SELECT COUNT(*) FROM pg_catalog.pg_proc) as functions
+  `;
+    const result = await executeInternalQuery(connection, logger, { query });
+    return {
+        tables: parseInt(result.rows[0]?.tables || '0', 10),
+        indexes: parseInt(result.rows[0]?.indexes || '0', 10),
+        sequences: parseInt(result.rows[0]?.sequences || '0', 10),
+        views: parseInt(result.rows[0]?.views || '0', 10),
+        functions: parseInt(result.rows[0]?.functions || '0', 10)
+    };
+}
+async function getConnectionStats(connection, logger) {
+    const query = `
+    SELECT
+      (SELECT COUNT(*) FROM pg_catalog.pg_stat_activity) as active,
+      (SELECT setting::int FROM pg_catalog.pg_settings WHERE name = 'max_connections') as max
+  `;
+    const result = await executeInternalQuery(connection, logger, { query });
+    return {
+        active: parseInt(result.rows[0]?.active || '0', 10),
+        max: parseInt(result.rows[0]?.max || '100', 10)
+    };
+}
+async function getCacheStats(connection, logger) {
+    const query = `
+    SELECT
+      CASE
+        WHEN (blks_hit + blks_read) = 0 THEN 0
+        ELSE ROUND(blks_hit::numeric / (blks_hit + blks_read), 4)
+      END as cache_hit_ratio,
+      xact_commit + xact_rollback as total_transactions
+    FROM pg_catalog.pg_stat_database
+    WHERE datname = current_database()
+  `;
+    const result = await executeInternalQuery(connection, logger, { query });
+    return {
+        ratio: parseFloat(result.rows[0]?.cache_hit_ratio || '0'),
+        transactionRate: parseInt(result.rows[0]?.total_transactions || '0', 10)
+    };
+}
+async function getTupleStats(connection, logger) {
+    const query = `
+    SELECT
+      tup_returned,
+      tup_fetched,
+      tup_inserted,
+      tup_updated,
+      tup_deleted
+    FROM pg_catalog.pg_stat_database
+    WHERE datname = current_database()
+  `;
+    const result = await executeInternalQuery(connection, logger, { query });
+    const row = result.rows[0] || {};
+    return {
+        returned: parseInt(row.tup_returned || '0', 10),
+        fetched: parseInt(row.tup_fetched || '0', 10),
+        inserted: parseInt(row.tup_inserted || '0', 10),
+        updated: parseInt(row.tup_updated || '0', 10),
+        deleted: parseInt(row.tup_deleted || '0', 10)
+    };
+}
+export const databaseTools = {
+    listDatabases: {
+        schema: ListDatabasesSchema,
+        handler: listDatabases
+    },
+    getDatabaseStats: {
+        schema: GetDatabaseStatsSchema,
+        handler: getDatabaseStats
+    }
+};
+//# sourceMappingURL=database.js.map

package/dist/tools/export.js

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+import { executeInternalQuery } from '../utils/database.js';
+import { escapeIdentifier, sanitizeIdentifier } from '../utils/sanitize.js';
+import { WhereConditionSchema, buildWhereClause } from '../utils/query-builder.js';
+const ExportTableSchema = z.object({
+    table: z.string(),
+    format: z.preprocess((val) => typeof val === 'string' ? val.toLowerCase() : val, z.enum(['csv', 'json', 'jsonl', 'sql'])),
+    schema: z.string().optional().default('public'),
+    where: z.array(WhereConditionSchema).optional(),
+    columns: z.array(z.string()).optional(),
+    limit: z.number().optional().default(10000),
+    includeHeaders: z.boolean().optional().default(true)
+});
+const GenerateInsertStatementsSchema = z.object({
+    table: z.string(),
+    schema: z.string().optional().default('public'),
+    where: z.array(WhereConditionSchema).optional(),
+    batchSize: z.number().optional().default(100),
+    includeSchema: z.boolean().optional().default(true),
+    limit: z.number().optional().default(1000)
+});
+export async function exportTable(connection, logger, args) {
+    const { table, format, schema, where, columns, limit, includeHeaders } = args;
+    logger.info('exportTable', 'Exporting table data', { table, format });
+    const sanitizedSchema = sanitizeIdentifier(schema);
+    const sanitizedTable = sanitizeIdentifier(table);
+    const columnList = columns && columns.length > 0
+        ? columns.map(sanitizeIdentifier).map(escapeIdentifier).join(', ')
+        : '*';
+    let whereClause = '';
+    let queryParams = [limit];
+    if (where && where.length > 0) {
+        const built = buildWhereClause(where, 2); // $1 is limit
+        whereClause = `WHERE ${built.clause}`;
+        queryParams = [limit, ...built.params];
+    }
+    const query = `
+    SELECT ${columnList}
+    FROM ${escapeIdentifier(sanitizedSchema)}.${escapeIdentifier(sanitizedTable)}
+    ${whereClause}
+    LIMIT $1
+  `;
+    const startTime = Date.now();
+    const result = await executeInternalQuery(connection, logger, {
+        query,
+        params: queryParams
+    });
+    const executionTimeMs = Date.now() - startTime;
+    let output = '';
+    let preview = '';
+    switch (format) {
+        case 'csv':
+            output = formatAsCSV(result.rows, includeHeaders);
+            preview = output.split('\n').slice(0, 5).join('\n');
+            break;
+        case 'json':
+            output = JSON.stringify(result.rows, null, 2);
+            preview = output.substring(0, 500);
+            break;
+        case 'jsonl':
+            output = result.rows.map(row => JSON.stringify(row)).join('\n');
+            preview = output.split('\n').slice(0, 5).join('\n');
+            break;
+        case 'sql':
+            output = formatAsSQL(sanitizedSchema, sanitizedTable, result.rows);
+            preview = output.split('\n').slice(0, 10).join('\n');
+            break;
+        default:
+            throw new Error(`Unsupported format: ${format}`);
+    }
+    const sizeBytes = Buffer.byteLength(output, 'utf8');
+    const sizeMB = (sizeBytes / 1024 / 1024).toFixed(2);
+    return {
+        table,
+        schema,
+        format,
+        rowsExported: result.rows.length,
+        sizeBytes,
+        sizeMB,
+        executionTimeMs,
+        preview: preview + (output.length > preview.length ? '\n...' : ''),
+        data: output
+    };
+}
+export async function generateInsertStatements(connection, logger, args) {
+    const { table, schema, where, batchSize, includeSchema, limit } = args;
+    logger.info('generateInsertStatements', 'Generating INSERT statements', { table });
+    const sanitizedSchema = sanitizeIdentifier(schema);
+    const sanitizedTable = sanitizeIdentifier(table);
+    const columnsQuery = `
+    SELECT column_name
+    FROM information_schema.columns
+    WHERE table_schema = $1
+      AND table_name = $2
+    ORDER BY ordinal_position
+  `;
+    const columnsResult = await executeInternalQuery(connection, logger, {
+        query: columnsQuery,
+        params: [sanitizedSchema, sanitizedTable]
+    });
+    const columns = columnsResult.rows.map(row => row.column_name);
+    let whereClause = '';
+    let dataQueryParams = [limit];
+    if (where && where.length > 0) {
+        const built = buildWhereClause(where, 2); // $1 is limit
+        whereClause = `WHERE ${built.clause}`;
+        dataQueryParams = [limit, ...built.params];
+    }
+    const dataQuery = `
+    SELECT *
+    FROM ${escapeIdentifier(sanitizedSchema)}.${escapeIdentifier(sanitizedTable)}
+    ${whereClause}
+    LIMIT $1
+  `;
+    const dataResult = await executeInternalQuery(connection, logger, {
+        query: dataQuery,
+        params: dataQueryParams
+    });
+    const statements = [];
+    const batches = Math.ceil(dataResult.rows.length / batchSize);
+    const tableName = includeSchema
+        ? `${escapeIdentifier(sanitizedSchema)}.${escapeIdentifier(sanitizedTable)}`
+        : escapeIdentifier(sanitizedTable);
+    for (let i = 0; i < batches; i++) {
+        const batchStart = i * batchSize;
+        const batchEnd = Math.min((i + 1) * batchSize, dataResult.rows.length);
+        const batchRows = dataResult.rows.slice(batchStart, batchEnd);
+        statements.push(`-- Batch ${i + 1} (${batchRows.length} rows)`);
+        const columnNames = columns.map(escapeIdentifier).join(', ');
+        statements.push(`INSERT INTO ${tableName} (${columnNames}) VALUES`);
+        const valueRows = batchRows.map((row, idx) => {
+            const values = columns.map(col => formatValue(row[col]));
+            const isLast = idx === batchRows.length - 1;
+            return `  (${values.join(', ')})${isLast ? ';' : ','}`;
+        });
+        statements.push(...valueRows);
+        statements.push('');
+    }
+    return {
+        table,
+        schema,
+        rowCount: dataResult.rows.length,
+        batchCount: batches,
+        batchSize,
+        statements: statements.join('\n')
+    };
+}
+function formatAsCSV(rows, includeHeaders) {
+    if (rows.length === 0)
+        return '';
+    const columns = Object.keys(rows[0]);
+    const lines = [];
+    function escapeCsvValue(value) {
+        const trimmed = value.trimStart();
+        const needsFormulaEscape = /^[=+\-@]/.test(trimmed);
+        const safeValue = needsFormulaEscape ? `'${value}` : value;
+        if (safeValue.includes(',') || safeValue.includes('"') || safeValue.includes('\n')) {
+            return `"${safeValue.replace(/"/g, '""')}"`;
+        }
+        return safeValue;
+    }
+    if (includeHeaders) {
+        lines.push(columns.join(','));
+    }
+    for (const row of rows) {
+        const values = columns.map(col => {
+            const value = row[col];
+            if (value === null || value === undefined)
+                return '';
+            const str = String(value);
+            return escapeCsvValue(str);
+        });
+        lines.push(values.join(','));
+    }
+    return lines.join('\n');
+}
+function formatAsSQL(schema, table, rows) {
+    if (rows.length === 0)
+        return '';
+    const columns = Object.keys(rows[0]);
+    const tableName = `${escapeIdentifier(schema)}.${escapeIdentifier(table)}`;
+    const columnNames = columns.map(escapeIdentifier).join(', ');
+    const statements = [];
+    statements.push(`-- INSERT statements for ${tableName}`);
+    statements.push(`INSERT INTO ${tableName} (${columnNames}) VALUES`);
+    const valueRows = rows.map((row, idx) => {
+        const values = columns.map(col => formatValue(row[col]));
+        const isLast = idx === rows.length - 1;
+        return `  (${values.join(', ')})${isLast ? ';' : ','}`;
+    });
+    statements.push(...valueRows);
+    return statements.join('\n');
+}
+function formatValue(value) {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    if (value instanceof Date) {
+        return `'${value.toISOString()}'`;
+    }
+    if (typeof value === 'object') {
+        return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+    }
+    const str = String(value);
+    return `'${str.replace(/'/g, "''")}'`;
+}
+export const exportTools = {
+    exportTable: {
+        schema: ExportTableSchema,
+        handler: exportTable
+    },
+    generateInsertStatements: {
+        schema: GenerateInsertStatementsSchema,
+        handler: generateInsertStatements
+    }
+};
+//# sourceMappingURL=export.js.map

package/dist/tools/index.js

@@ -0,0 +1,52 @@
+import { databaseTools } from './database.js';
+import { schemaTools } from './schema.js';
+import { queryTools } from './query.js';
+import { dataQualityTools } from './data-quality.js';
+import { temporalTools } from './temporal.js';
+import { monitoringTools } from './monitoring.js';
+import { relationshipTools } from './relationships.js';
+import { exportTools } from './export.js';
+import { maintenanceTools } from './maintenance.js';
+import { optimizationTools } from './optimization.js';
+import { mutationTools } from './mutations.js';
+import { liveMonitoringTools } from './live-monitoring.js';
+export const tools = {
+    ...databaseTools,
+    ...schemaTools,
+    ...queryTools,
+    ...dataQualityTools,
+    ...temporalTools,
+    ...monitoringTools,
+    ...relationshipTools,
+    ...exportTools,
+    ...maintenanceTools,
+    ...optimizationTools,
+    ...mutationTools,
+    ...liveMonitoringTools
+};
+export function getToolNames() {
+    return Object.keys(tools);
+}
+export function getTool(name) {
+    return tools[name];
+}
+export async function executeTool(name, connection, logger, args) {
+    const tool = getTool(name);
+    if (!tool) {
+        throw new Error(`Tool "${name}" not found`);
+    }
+    const validatedArgs = tool.schema.parse(args);
+    logger.info('tool', `Executing tool: ${name}`, { args: validatedArgs });
+    try {
+        const result = await tool.handler(connection, logger, validatedArgs);
+        logger.info('tool', `Tool ${name} completed successfully`);
+        return result;
+    }
+    catch (error) {
+        logger.error('tool', `Tool ${name} failed`, {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=index.js.map