mcp-migration-advisor 0.2.5 → 0.2.7

package/README.md

@@ -22,6 +22,19 @@ Unlike MigrationPilot (PG-only, raw SQL analysis), this tool **parses Liquibase
 - **Rollback Validation**: Checks rollback completeness for each changeSet
 - **Actionable Recommendations**: Every risk includes a specific safe alternative
 
+## Pro Tier
+
+**Generate exportable diagnostic reports (HTML + PDF)** with a Pro license key.
+
+- Full JVM thread dump analysis report with actionable recommendations
+- PDF export for sharing with your team
+- Priority support
+
+<!-- TODO: replace placeholder Stripe Payment Link once STRIPE_SECRET_KEY is configured -->
+**$9.99/month** — [Get Pro License](https://buy.stripe.com/PLACEHOLDER)
+
+Pro license key activates the `generate_report` MCP tool in mcp-jvm-diagnostics.
+
 ## Installation
 
 ```bash

package/build/analyzers/data-loss.js

@@ -76,7 +76,7 @@ export function analyzeDataLoss(migration) {
             case "OTHER": {
                 // Detect TRUNCATE
                 if (upper.includes("TRUNCATE")) {
-                    const tableMatch = stmt.raw.match(/TRUNCATE\s+(?:TABLE\s+)?(?:`|"|)?(\w+)/i);
+                    const tableMatch = stmt.raw.match(/TRUNCATE\s+(?:TABLE\s+)?(?:`|"|)?(?:\w+\.)?(\w+)/i);
                     issues.push({
                         risk: "CERTAIN",
                         statement: truncate(stmt.raw),
@@ -87,7 +87,7 @@ export function analyzeDataLoss(migration) {
                 }
                 // Detect DELETE without WHERE
                 if (upper.match(/DELETE\s+FROM/) && !upper.includes("WHERE")) {
-                    const tableMatch = stmt.raw.match(/DELETE\s+FROM\s+(?:`|"|)?(\w+)/i);
+                    const tableMatch = stmt.raw.match(/DELETE\s+FROM\s+(?:`|"|)?(?:\w+\.)?(\w+)/i);
                     issues.push({
                         risk: "CERTAIN",
                         statement: truncate(stmt.raw),
@@ -98,7 +98,7 @@ export function analyzeDataLoss(migration) {
                 }
                 // Detect UPDATE without WHERE
                 if (upper.match(/^UPDATE\b/) && !upper.includes("WHERE")) {
-                    const tableMatch = stmt.raw.match(/UPDATE\s+(?:`|"|)?(\w+)/i);
+                    const tableMatch = stmt.raw.match(/UPDATE\s+(?:`|"|)?(?:\w+\.)?(\w+)/i);
                     issues.push({
                         risk: "LIKELY",
                         statement: truncate(stmt.raw),

package/build/analyzers/lock-risk.js

@@ -149,7 +149,7 @@ function analyzeStatement(stmt) {
     }
     // TRUNCATE acquires ACCESS EXCLUSIVE lock — same severity as DROP TABLE
     if (stmt.type === "OTHER" && /\bTRUNCATE\b/i.test(stmt.raw)) {
-        const tableMatch = stmt.raw.match(/TRUNCATE\s+(?:TABLE\s+)?(?:`|"|)?(\w+)/i);
+        const tableMatch = stmt.raw.match(/TRUNCATE\s+(?:TABLE\s+)?(?:`|"|)?(?:\w+\.)?(\w+)/i);
         risks.push({
             severity: "HIGH",
             statement: truncate(stmt.raw),

package/build/generators/rollback.js

@@ -132,6 +132,22 @@ function generateRollbackStatement(stmt) {
                     warning: `Type change on ${stmt.tableName}.${stmt.columnName} requires knowing the original type. Check schema before migration.`,
                 };
             }
+            if (stmt.details.setDefault === "true") {
+                return {
+                    forward: stmt.raw,
+                    rollback: `ALTER TABLE ${stmt.tableName} ALTER COLUMN ${stmt.columnName} DROP DEFAULT`,
+                    isReversible: true,
+                    warning: null,
+                };
+            }
+            if (stmt.details.dropDefault === "true") {
+                return {
+                    forward: stmt.raw,
+                    rollback: `-- Cannot reverse DROP DEFAULT on ${stmt.tableName}.${stmt.columnName} — original default value unknown`,
+                    isReversible: false,
+                    warning: `DROP DEFAULT on ${stmt.tableName}.${stmt.columnName} requires knowing the original default value to reverse.`,
+                };
+            }
             return {
                 forward: stmt.raw,
                 rollback: `-- Cannot reverse: ${stmt.raw.slice(0, 80)}`,

package/build/index.js

@@ -33,7 +33,7 @@ function formatParserWarnings(migration) {
 }
 // Handle --help
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
-    console.log(`mcp-migration-advisor v0.2.5 — MCP server for database migration risk analysis
+    console.log(`mcp-migration-advisor v0.2.6 — MCP server for database migration risk analysis
 
 Usage:
   mcp-migration-advisor [options]
@@ -52,7 +52,7 @@ Tools provided:
 }
 const server = new McpServer({
     name: "mcp-migration-advisor",
-    version: "0.2.5",
+    version: "0.2.6",
 });
 // Tool 1: analyze_migration
 server.tool("analyze_migration", "Analyze a SQL migration file for lock risks, data loss potential, and unsafe patterns. Supports Flyway (V__*.sql) and plain SQL.", {
@@ -190,7 +190,7 @@ server.tool("analyze_liquibase_yaml", "Analyze a Liquibase YAML changelog for lo
     return { content: [{ type: "text", text: output }] };
 });
 // Tool 4: score_risk
-server.tool("score_risk", "Calculate the overall risk score (0-100) for a SQL migration. Higher scores indicate more dangerous migrations.", {
+server.tool("score_risk", "Calculate the combined risk score (0-100) for a SQL migration. Aggregates both lock risk severity (ACCESS EXCLUSIVE, SHARE locks) and data loss potential (DROP, TRUNCATE, type changes) into a single score. Useful for CI gates and automated migration review pipelines.", {
     filename: z.string().describe("Migration filename"),
     sql: z.string().describe("The SQL content of the migration file"),
 }, async ({ filename, sql }) => {
@@ -200,6 +200,8 @@ server.tool("score_risk", "Calculate the overall risk score (0-100) for a SQL mi
     const riskScore = calculateRiskScore(lockRisks);
     const criticalCount = lockRisks.filter(r => r.severity === "CRITICAL").length;
     const highCount = lockRisks.filter(r => r.severity === "HIGH").length;
+    const mediumCount = lockRisks.filter(r => r.severity === "MEDIUM").length;
+    const lowCount = lockRisks.filter(r => r.severity === "LOW").length;
     const dataLossCertain = dataLossIssues.filter(i => i.risk === "CERTAIN").length;
     const dataLossLikely = dataLossIssues.filter(i => i.risk === "LIKELY").length;
     const dataLossPossible = dataLossIssues.filter(i => i.risk === "POSSIBLE").length;
@@ -226,6 +228,8 @@ server.tool("score_risk", "Calculate the overall risk score (0-100) for a SQL mi
 |----------|-------|--------------------|
 | CRITICAL lock risks | ${criticalCount} | ${criticalCount * 30} |
 | HIGH lock risks | ${highCount} | ${highCount * 20} |
+| MEDIUM lock risks | ${mediumCount} | ${mediumCount * 10} |
+| LOW lock risks | ${lowCount} | ${lowCount * 5} |
 | Certain data loss | ${dataLossCertain} | ${dataLossCertain * 25} |
 | Likely data loss | ${dataLossLikely} | ${dataLossLikely * 15} |
 | Possible data loss | ${dataLossPossible} | ${dataLossPossible * 5} |
@@ -235,7 +239,7 @@ server.tool("score_risk", "Calculate the overall risk score (0-100) for a SQL mi
         content: [{ type: "text", text: output }],
     };
 });
-// Tool 4: generate_rollback
+// Tool 5: generate_rollback
 server.tool("generate_rollback", "Generate reverse DDL to undo a SQL migration. Produces rollback SQL with warnings for irreversible operations (DROP TABLE, DROP COLUMN, type changes). Includes Flyway schema_history cleanup.", {
     filename: z.string().describe("Migration filename (e.g., V2__add_user_email.sql)"),
     sql: z.string().describe("The SQL content of the migration file"),

package/build/parsers/flyway-sql.js

@@ -33,6 +33,8 @@ export function parseFlywayFilename(filename) {
  * Split SQL text into individual statements.
  * Handles semicolons, ignoring those inside string literals and comments.
  * Single-quoted strings are tracked; escaped quotes ('') are handled correctly.
+ * PostgreSQL dollar-quoted strings ($$ or $tag$) are also tracked so that
+ * semicolons inside function/trigger bodies are not treated as statement separators.
  */
 function splitStatements(sql) {
     // Remove block comments
@@ -42,9 +44,40 @@ function splitStatements(sql) {
     const stmts = [];
     let current = "";
     let inString = false;
+    let dollarTag = null; // non-null while inside a $tag$...$tag$ block
     let i = 0;
     while (i < cleaned.length) {
         const char = cleaned[i];
+        // Dollar-quote handling (PostgreSQL $tag$...$tag$ or $$...$$).
+        // Must be checked before the regular single-quote path.
+        if (char === "$" && !inString) {
+            const rest = cleaned.substring(i);
+            if (dollarTag === null) {
+                // Try to open a dollar-quoted block
+                const openMatch = rest.match(/^\$(\w*)\$/);
+                if (openMatch) {
+                    dollarTag = openMatch[0]; // e.g. "$$" or "$body$"
+                    current += dollarTag;
+                    i += dollarTag.length;
+                    continue;
+                }
+            }
+            else {
+                // Try to close the current dollar-quoted block
+                if (rest.startsWith(dollarTag)) {
+                    current += dollarTag;
+                    i += dollarTag.length;
+                    dollarTag = null;
+                    continue;
+                }
+            }
+        }
+        // While inside a dollar-quoted block, pass everything through verbatim
+        if (dollarTag !== null) {
+            current += char;
+            i++;
+            continue;
+        }
         if (char === "'" && !inString) {
             inString = true;
             current += char;
@@ -81,11 +114,13 @@ function splitStatements(sql) {
     }
     return stmts;
 }
-// Pattern matchers for DDL statement types
-const CREATE_TABLE_RE = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
-const ALTER_TABLE_RE = /ALTER\s+TABLE\s+(?:ONLY\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
-const DROP_TABLE_RE = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
-const CREATE_INDEX_RE = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|\s).*?\bON\s+(?:`|"|)?(\w+)(?:`|"|)?/i;
+// Pattern matchers for DDL statement types.
+// Table name patterns use (?:\w+\.)? to optionally consume a schema prefix (e.g. public.users),
+// so that only the unqualified table name is captured in group 1.
+const CREATE_TABLE_RE = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|)?(?:\w+\.)?(\w+)(?:`|"|)?/i;
+const ALTER_TABLE_RE = /ALTER\s+TABLE\s+(?:ONLY\s+)?(?:`|"|)?(?:\w+\.)?(\w+)(?:`|"|)?/i;
+const DROP_TABLE_RE = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:`|"|)?(?:\w+\.)?(\w+)(?:`|"|)?/i;
+const CREATE_INDEX_RE = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|\s).*?\bON\s+(?:`|"|)?(?:\w+\.)?(\w+)(?:`|"|)?/i;
 const DROP_INDEX_RE = /DROP\s+INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
 const ADD_COLUMN_RE = /ADD\s+(?:COLUMN\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
 const DROP_COLUMN_RE = /DROP\s+(?:COLUMN\s+)?(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-migration-advisor",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "MCP server for database migration risk analysis — Flyway and Liquibase XML/YAML/SQL support with lock detection and conflict analysis",
   "mcpName": "io.github.dmitriusan/mcp-migration-advisor",
   "main": "build/index.js",