mcp-migration-advisor 0.2.0

package/build/parsers/liquibase-yaml.js

@@ -0,0 +1,381 @@
+/**
+ * Liquibase YAML changelog parser.
+ *
+ * Parses Liquibase YAML changelogs and extracts DDL operations
+ * compatible with the same DDLStatement interface used by Flyway and XML.
+ */
+/**
+ * Parse a Liquibase YAML changelog and extract DDL statements.
+ *
+ * Supports: createTable, dropTable, addColumn, dropColumn, modifyDataType,
+ * addNotNullConstraint, createIndex, dropIndex, addForeignKeyConstraint,
+ * dropForeignKeyConstraint, renameTable, renameColumn, sql (raw).
+ */
+export function parseLiquibaseYaml(yaml) {
+    const changeSets = extractChangeSets(yaml);
+    const allStatements = [];
+    for (const cs of changeSets) {
+        allStatements.push(...cs.statements);
+    }
+    return {
+        version: changeSets.length > 0 ? changeSets[0].id : null,
+        description: `Liquibase changelog (${changeSets.length} changeSets)`,
+        filename: "changelog.yaml",
+        isRepeatable: false,
+        statements: allStatements,
+    };
+}
+function extractChangeSets(yaml) {
+    const results = [];
+    // Split into lines for indentation-based parsing
+    const lines = yaml.split("\n");
+    // Find changeSet blocks by scanning for "- changeSet:" pattern
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const csMatch = line.match(/^(\s*)-\s*changeSet\s*:/);
+        if (!csMatch) {
+            i++;
+            continue;
+        }
+        const baseIndent = csMatch[1].length;
+        // Collect all lines belonging to this changeSet
+        const csLines = [];
+        i++;
+        while (i < lines.length) {
+            const nextLine = lines[i];
+            // Empty lines are part of the block
+            if (nextLine.trim() === "") {
+                csLines.push(nextLine);
+                i++;
+                continue;
+            }
+            // Check if we've exited the changeSet block
+            const nextIndent = nextLine.search(/\S/);
+            if (nextIndent <= baseIndent && nextLine.trim().startsWith("-"))
+                break;
+            if (nextIndent <= baseIndent && !nextLine.trim().startsWith("-"))
+                break;
+            csLines.push(nextLine);
+            i++;
+        }
+        const csBody = csLines.join("\n");
+        const id = extractValue(csBody, "id") || "unknown";
+        const author = extractValue(csBody, "author") || "unknown";
+        const statements = parseChanges(csBody);
+        results.push({ id, author, statements });
+    }
+    return results;
+}
+function extractValue(text, key) {
+    // Match key: value or key: "value" (with optional quotes)
+    const re = new RegExp(`\\b${key}\\s*:\\s*["']?([^"'\\n]+?)["']?\\s*$`, "m");
+    const m = text.match(re);
+    return m ? m[1].trim() : null;
+}
+function parseChanges(csBody) {
+    const statements = [];
+    // Find the "changes:" block
+    const changesIdx = csBody.indexOf("changes:");
+    if (changesIdx === -1)
+        return statements;
+    const changesBody = csBody.substring(changesIdx);
+    // Parse each change type
+    parseCreateTable(changesBody, statements);
+    parseDropTable(changesBody, statements);
+    parseAddColumn(changesBody, statements);
+    parseDropColumn(changesBody, statements);
+    parseModifyDataType(changesBody, statements);
+    parseAddNotNullConstraint(changesBody, statements);
+    parseCreateIndex(changesBody, statements);
+    parseDropIndex(changesBody, statements);
+    parseAddForeignKeyConstraint(changesBody, statements);
+    parseDropForeignKeyConstraint(changesBody, statements);
+    parseRenameTable(changesBody, statements);
+    parseRenameColumn(changesBody, statements);
+    parseRawSql(changesBody, statements);
+    return statements;
+}
+function extractChangeBlock(body, changeName) {
+    const blocks = [];
+    const re = new RegExp(`-\\s*${changeName}\\s*:`, "g");
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        const startIdx = m.index + m[0].length;
+        const blockIndent = body.substring(0, m.index).split("\n").pop().search(/\S/);
+        const remaining = body.substring(startIdx);
+        const lines = remaining.split("\n");
+        const blockLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === "") {
+                blockLines.push(line);
+                continue;
+            }
+            const indent = line.search(/\S/);
+            // If we hit something at same or lower indent that starts a new change, stop
+            if (i > 0 && indent <= blockIndent + 2 && line.trim().startsWith("-"))
+                break;
+            if (i > 0 && indent <= blockIndent)
+                break;
+            blockLines.push(line);
+        }
+        blocks.push(blockLines.join("\n"));
+    }
+    return blocks;
+}
+function parseCreateTable(body, statements) {
+    for (const block of extractChangeBlock(body, "createTable")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const columns = extractColumnNames(block);
+        const details = {};
+        if (columns.length > 0)
+            details.columns = columns.join(", ");
+        statements.push({
+            type: "CREATE_TABLE",
+            raw: `createTable: ${tableName}`,
+            tableName,
+            columnName: null,
+            details,
+        });
+    }
+}
+function parseDropTable(body, statements) {
+    for (const block of extractChangeBlock(body, "dropTable")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const details = {};
+        const cascade = extractValue(block, "cascadeConstraints");
+        if (cascade === "true")
+            details.cascade = "true";
+        statements.push({
+            type: "DROP_TABLE",
+            raw: `dropTable: ${tableName}`,
+            tableName,
+            columnName: null,
+            details,
+        });
+    }
+}
+function parseAddColumn(body, statements) {
+    for (const block of extractChangeBlock(body, "addColumn")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        // Find column entries
+        const colNames = extractColumnEntries(block);
+        for (const col of colNames) {
+            const details = {};
+            if (col.type)
+                details.type = col.type;
+            if (col.nullable === "false")
+                details.notNull = "true";
+            if (col.defaultValue)
+                details.hasDefault = "true";
+            statements.push({
+                type: "ADD_COLUMN",
+                raw: `addColumn: ${tableName}.${col.name}`,
+                tableName,
+                columnName: col.name,
+                details,
+            });
+        }
+    }
+}
+function parseDropColumn(body, statements) {
+    for (const block of extractChangeBlock(body, "dropColumn")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const colName = extractValue(block, "columnName") || "unknown";
+        statements.push({
+            type: "DROP_COLUMN",
+            raw: `dropColumn: ${tableName}.${colName}`,
+            tableName,
+            columnName: colName,
+            details: {},
+        });
+    }
+}
+function parseModifyDataType(body, statements) {
+    for (const block of extractChangeBlock(body, "modifyDataType")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const colName = extractValue(block, "columnName") || "unknown";
+        const newType = extractValue(block, "newDataType");
+        const details = { typeChange: "true" };
+        if (newType)
+            details.newType = newType;
+        statements.push({
+            type: "MODIFY_COLUMN",
+            raw: `modifyDataType: ${tableName}.${colName}`,
+            tableName,
+            columnName: colName,
+            details,
+        });
+    }
+}
+function parseAddNotNullConstraint(body, statements) {
+    for (const block of extractChangeBlock(body, "addNotNullConstraint")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const colName = extractValue(block, "columnName") || "unknown";
+        const details = { setNotNull: "true" };
+        const defaultVal = extractValue(block, "defaultNullValue");
+        if (defaultVal)
+            details.hasDefault = "true";
+        statements.push({
+            type: "MODIFY_COLUMN",
+            raw: `addNotNullConstraint: ${tableName}.${colName}`,
+            tableName,
+            columnName: colName,
+            details,
+        });
+    }
+}
+function parseCreateIndex(body, statements) {
+    for (const block of extractChangeBlock(body, "createIndex")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const details = {};
+        if (extractValue(block, "unique") === "true")
+            details.unique = "true";
+        statements.push({
+            type: "CREATE_INDEX",
+            raw: `createIndex: ${tableName}`,
+            tableName,
+            columnName: null,
+            details,
+        });
+    }
+}
+function parseDropIndex(body, statements) {
+    for (const block of extractChangeBlock(body, "dropIndex")) {
+        const tableName = extractValue(block, "tableName") || null;
+        statements.push({
+            type: "DROP_INDEX",
+            raw: `dropIndex`,
+            tableName,
+            columnName: null,
+            details: {},
+        });
+    }
+}
+function parseAddForeignKeyConstraint(body, statements) {
+    for (const block of extractChangeBlock(body, "addForeignKeyConstraint")) {
+        const tableName = extractValue(block, "baseTableName") || "unknown";
+        const constraintName = extractValue(block, "constraintName") || "unknown";
+        statements.push({
+            type: "ADD_CONSTRAINT",
+            raw: `addForeignKeyConstraint: ${constraintName}`,
+            tableName,
+            columnName: null,
+            details: { constraintName, constraintType: "FOREIGN_KEY" },
+        });
+    }
+}
+function parseDropForeignKeyConstraint(body, statements) {
+    for (const block of extractChangeBlock(body, "dropForeignKeyConstraint")) {
+        const tableName = extractValue(block, "baseTableName") || "unknown";
+        const constraintName = extractValue(block, "constraintName") || "unknown";
+        statements.push({
+            type: "DROP_CONSTRAINT",
+            raw: `dropForeignKeyConstraint: ${constraintName}`,
+            tableName,
+            columnName: null,
+            details: { constraintName },
+        });
+    }
+}
+function parseRenameTable(body, statements) {
+    for (const block of extractChangeBlock(body, "renameTable")) {
+        const oldName = extractValue(block, "oldTableName");
+        const newName = extractValue(block, "newTableName");
+        statements.push({
+            type: "RENAME",
+            raw: `renameTable: ${oldName} -> ${newName}`,
+            tableName: oldName || "unknown",
+            columnName: null,
+            details: { newName: newName || "unknown" },
+        });
+    }
+}
+function parseRenameColumn(body, statements) {
+    for (const block of extractChangeBlock(body, "renameColumn")) {
+        const tableName = extractValue(block, "tableName") || "unknown";
+        const oldName = extractValue(block, "oldColumnName");
+        const newName = extractValue(block, "newColumnName");
+        statements.push({
+            type: "RENAME",
+            raw: `renameColumn: ${tableName}.${oldName} -> ${newName}`,
+            tableName,
+            columnName: oldName || null,
+            details: { newName: newName || "unknown" },
+        });
+    }
+}
+function parseRawSql(body, statements) {
+    for (const block of extractChangeBlock(body, "sql")) {
+        // The block content after "- sql:" is the raw SQL
+        const sql = block.trim();
+        if (sql) {
+            statements.push({
+                type: "OTHER",
+                raw: sql,
+                tableName: null,
+                columnName: null,
+                details: { source: "inline-sql" },
+            });
+        }
+    }
+}
+function extractColumnEntries(block) {
+    const columns = [];
+    // Find "- column:" blocks
+    const colRe = /-\s*column\s*:/g;
+    let m;
+    const lines = block.split("\n");
+    let lineIdx = 0;
+    while (lineIdx < lines.length) {
+        const line = lines[lineIdx];
+        if (!line.match(/-\s*column\s*:/)) {
+            lineIdx++;
+            continue;
+        }
+        // Collect column block
+        const colIndent = line.search(/\S/);
+        const colLines = [];
+        lineIdx++;
+        while (lineIdx < lines.length) {
+            const next = lines[lineIdx];
+            if (next.trim() === "") {
+                colLines.push(next);
+                lineIdx++;
+                continue;
+            }
+            const nextIndent = next.search(/\S/);
+            if (nextIndent <= colIndent)
+                break;
+            colLines.push(next);
+            lineIdx++;
+        }
+        const colBody = colLines.join("\n");
+        const name = extractValue(colBody, "name");
+        if (name) {
+            const entry = { name };
+            const type = extractValue(colBody, "type");
+            if (type)
+                entry.type = type;
+            // Check constraints block for nullable
+            if (colBody.includes("nullable:")) {
+                const nullable = extractValue(colBody, "nullable");
+                if (nullable)
+                    entry.nullable = nullable;
+            }
+            // Check for default values
+            const defaultValue = extractValue(colBody, "defaultValue") ||
+                extractValue(colBody, "defaultValueNumeric") ||
+                extractValue(colBody, "defaultValueBoolean");
+            if (defaultValue)
+                entry.defaultValue = defaultValue;
+            columns.push(entry);
+        }
+    }
+    return columns;
+}
+function extractColumnNames(block) {
+    return extractColumnEntries(block).map((c) => c.name);
+}
+//# sourceMappingURL=liquibase-yaml.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "mcp-migration-advisor",
+  "version": "0.2.0",
+  "description": "MCP server for database migration risk analysis — Flyway and Liquibase XML/YAML/SQL support with lock detection and conflict analysis",
+  "main": "build/index.js",
+  "bin": {
+    "mcp-migration-advisor": "build/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "files": [
+    "build/**/*.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "database",
+    "migration",
+    "flyway",
+    "liquibase",
+    "schema",
+    "risk-analysis",
+    "postgresql",
+    "mysql",
+    "ai",
+    "claude"
+  ],
+  "author": "Dmytro Lisnichenko",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dmitriusan/mcp-migration-advisor"
+  },
+  "homepage": "https://github.com/Dmitriusan/mcp-migration-advisor#readme",
+  "bugs": {
+    "url": "https://github.com/Dmitriusan/mcp-migration-advisor/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.2",
+    "vitest": "^4.0.18"
+  }
+}