@amazon-sp-api-release/dev-mcp 0.0.1

package/dist/tools/api-tools/orders-api-tools.js

@@ -0,0 +1,459 @@
+import { SPAPIAuth } from "../../auth/sp-api-auth.js";
+export class OrdersApiTool {
+    config;
+    auth;
+    hasCredentials;
+    constructor(config) {
+        this.config = {
+            ...config,
+            baseUrl: config?.baseUrl || "https://sellingpartnerapi-na.amazon.com",
+        };
+        this.hasCredentials = !!(this.config.clientId &&
+            this.config.clientSecret &&
+            this.config.refreshToken);
+        if (this.hasCredentials) {
+            this.auth = new SPAPIAuth(this.config);
+        }
+    }
+    checkCredentials() {
+        if (!this.hasCredentials) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **SP-API Credentials Required**
+
+To use this tool, you need to provide SP-API credentials
+
+**Environment variables**:
+\`\`\`bash
+export SP_API_CLIENT_ID="your_client_id"
+export SP_API_CLIENT_SECRET="your_client_secret"
+export SP_API_REFRESH_TOKEN="your_refresh_token"
+export SP_API_BASE_URL="https://sellingpartnerapi-na.amazon.com"
+\`\`\`
+
+**Note:** The migration assistant tool does not require credentials and can be used without API access.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return null;
+    }
+    async searchOrders(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { createdAfter, createdBefore, lastUpdatedAfter, lastUpdatedBefore, fulfillmentStatuses, marketplaceIds = ["ATVPDKIKX0DER"], fulfilledBy, maxResultsPerPage = 50, includedData = [], paginationToken, } = args;
+        // Validate date parameters
+        if (!createdAfter && !lastUpdatedAfter) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Either createdAfter or lastUpdatedAfter must be provided",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const queryParams = {
+            marketplaceIds: marketplaceIds.join(","),
+            maxResultsPerPage: maxResultsPerPage.toString(),
+        };
+        if (createdAfter)
+            queryParams.createdAfter = createdAfter;
+        if (createdBefore)
+            queryParams.createdBefore = createdBefore;
+        if (lastUpdatedAfter)
+            queryParams.lastUpdatedAfter = lastUpdatedAfter;
+        if (lastUpdatedBefore)
+            queryParams.lastUpdatedBefore = lastUpdatedBefore;
+        if (fulfillmentStatuses && fulfillmentStatuses.length > 0) {
+            queryParams.fulfillmentStatuses = fulfillmentStatuses.join(",");
+        }
+        if (fulfilledBy && fulfilledBy.length > 0) {
+            queryParams.fulfilledBy = fulfilledBy.join(",");
+        }
+        if (includedData.length > 0) {
+            queryParams.includedData = includedData.join(",");
+        }
+        if (paginationToken) {
+            queryParams.paginationToken = paginationToken;
+        }
+        try {
+            const response = await this.auth.makeAuthenticatedRequest("GET", `${this.config.baseUrl}/orders/2026-01-01/orders`, queryParams);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: this.formatOrdersResponse(response.data),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async getOrder(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { orderId, includedData = [] } = args;
+        const queryParams = {};
+        if (includedData.length > 0) {
+            queryParams.includedData = includedData.join(",");
+        }
+        try {
+            const response = await this.auth.makeAuthenticatedRequest("GET", `${this.config.baseUrl}/orders/2026-01-01/orders/${orderId}`, queryParams);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: this.formatOrderResponse(response.data.order),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async cancelOrder(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { orderId, cancelReasonCode } = args;
+        const requestBody = {
+            cancelReasonCode: cancelReasonCode,
+        };
+        try {
+            await this.auth.makeAuthenticatedRequest("PUT", `${this.config.baseUrl}/orders/2026-01-01/orders/${orderId}/cancellation`, {}, requestBody);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ Order cancellation request accepted for order ${orderId}. The cancellation process is underway.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    // V0 APIs
+    async updateShipmentStatus(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { orderId, marketplaceId, shipmentStatus, orderItems } = args;
+        const requestBody = {
+            marketplaceId,
+            shipmentStatus,
+        };
+        if (orderItems && orderItems.length > 0) {
+            requestBody.orderItems = orderItems;
+        }
+        try {
+            const response = await this.auth.makeAuthenticatedRequest("POST", `${this.config.baseUrl}/orders/v0/orders/${orderId}/shipment`, {}, requestBody);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ Shipment status updated successfully for order ${orderId}.\n\nResponse: ${JSON.stringify(response.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error updating shipment status: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async updateVerificationStatus(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { orderId, marketplaceId, regulatedOrderVerificationStatus } = args;
+        const requestBody = {
+            marketplaceId,
+            regulatedOrderVerificationStatus,
+        };
+        try {
+            const response = await this.auth.makeAuthenticatedRequest("PATCH", `${this.config.baseUrl}/orders/v0/orders/${orderId}/regulatedInfo`, {}, requestBody);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ Verification status updated successfully for order ${orderId}.\n\nResponse: ${JSON.stringify(response.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error updating verification status: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async confirmShipment(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { orderId, marketplaceId, packageDetail, codCollectionMethod } = args;
+        const requestBody = {
+            marketplaceId,
+            packageDetail,
+        };
+        if (codCollectionMethod) {
+            requestBody.codCollectionMethod = codCollectionMethod;
+        }
+        try {
+            const response = await this.auth.makeAuthenticatedRequest("POST", `${this.config.baseUrl}/orders/v0/orders/${orderId}/shipmentConfirmation`, {}, requestBody);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ Shipment confirmed successfully for order ${orderId}.\n\nResponse: ${JSON.stringify(response.data, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error confirming shipment: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async getOrderRegulatedInfo(args) {
+        const credentialError = this.checkCredentials();
+        if (credentialError)
+            return credentialError;
+        const { orderId } = args;
+        try {
+            const response = await this.auth.makeAuthenticatedRequest("GET", `${this.config.baseUrl}/orders/v0/orders/${orderId}/regulatedInfo`, {});
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: this.formatRegulatedInfoResponse(response.data),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting regulated info: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    formatOrdersResponse(data) {
+        if (!data.orders || data.orders.length === 0) {
+            return "No orders found matching the criteria.";
+        }
+        let result = `📦 Found ${data.orders.length} orders:\n\n`;
+        result += "=".repeat(50) + "\n\n";
+        data.orders.forEach((order, index) => {
+            result += `**Order ${index + 1}**\n`;
+            result += `Order ID: ${order.orderId}\n`;
+            result += `Created: ${new Date(order.createdTime).toLocaleDateString()}\n`;
+            result += `Status: ${order.fulfillment?.fulfillmentStatus || "Unknown"}\n`;
+            result += `Marketplace: ${order.salesChannel?.marketplaceName || "N/A"}\n`;
+            if (order.buyer) {
+                result += `Buyer: ${order.buyer.buyerName || "N/A"}\n`;
+            }
+            if (order.recipient?.deliveryAddress) {
+                const addr = order.recipient.deliveryAddress;
+                result += `Shipping: ${addr.addressLine1 || ""}, ${addr.city || ""}, ${addr.stateOrRegion || ""} ${addr.postalCode || ""}\n`;
+            }
+            if (order.orderItems && order.orderItems.length > 0) {
+                result += `Items: ${order.orderItems.length} item(s)\n`;
+                order.orderItems.forEach((item, itemIndex) => {
+                    const price = item.product?.price?.unitPrice;
+                    const priceStr = price
+                        ? `${price.amount} ${price.currencyCode}`
+                        : "N/A";
+                    result += `  ${itemIndex + 1}. ${item.product?.title || "Unknown"} (Qty: ${item.quantityOrdered}, Price: ${priceStr})\n`;
+                });
+            }
+            result += "\n" + "-".repeat(40) + "\n\n";
+        });
+        if (data.pagination?.nextToken) {
+            result += `\n🔗 **Next page available** - Use paginationToken: ${data.pagination.nextToken}`;
+        }
+        return result;
+    }
+    formatOrderResponse(order) {
+        let result = `📋 **Order Details**\n\n`;
+        result += "=".repeat(50) + "\n\n";
+        result += `**Basic Information**\n`;
+        result += `Order ID: ${order.orderId}\n`;
+        result += `Created: ${new Date(order.createdTime).toLocaleString()}\n`;
+        result += `Last Updated: ${new Date(order.lastUpdatedTime).toLocaleString()}\n`;
+        result += `Marketplace: ${order.salesChannel?.marketplaceName || "N/A"}\n`;
+        result += `Channel: ${order.salesChannel?.channelName || "N/A"}\n`;
+        if (order.programs && order.programs.length > 0) {
+            result += `Programs: ${order.programs.join(", ")}\n`;
+        }
+        if (order.buyer) {
+            result += `\n**Buyer Information**\n`;
+            result += `Name: ${order.buyer.buyerName || "N/A"}\n`;
+            result += `Email: ${order.buyer.buyerEmail || "N/A"}\n`;
+            if (order.buyer.buyerCompanyName) {
+                result += `Company: ${order.buyer.buyerCompanyName}\n`;
+            }
+            if (order.buyer.buyerPurchaseOrderNumber) {
+                result += `PO Number: ${order.buyer.buyerPurchaseOrderNumber}\n`;
+            }
+        }
+        if (order.recipient?.deliveryAddress) {
+            result += `\n**Shipping Address**\n`;
+            const addr = order.recipient.deliveryAddress;
+            result += `Name: ${addr.name || "N/A"}\n`;
+            if (addr.companyName)
+                result += `Company: ${addr.companyName}\n`;
+            result += `Address: ${addr.addressLine1 || ""}\n`;
+            if (addr.addressLine2)
+                result += `         ${addr.addressLine2}\n`;
+            if (addr.addressLine3)
+                result += `         ${addr.addressLine3}\n`;
+            result += `City: ${addr.city || "N/A"}\n`;
+            result += `State/Region: ${addr.stateOrRegion || "N/A"}\n`;
+            result += `Postal Code: ${addr.postalCode || "N/A"}\n`;
+            result += `Country: ${addr.countryCode || "N/A"}\n`;
+            if (addr.phone)
+                result += `Phone: ${addr.phone}\n`;
+            result += `Address Type: ${addr.addressType || "N/A"}\n`;
+        }
+        if (order.fulfillment) {
+            result += `\n**Fulfillment Information**\n`;
+            result += `Status: ${order.fulfillment.fulfillmentStatus}\n`;
+            result += `Fulfilled By: ${order.fulfillment.fulfilledBy}\n`;
+            if (order.fulfillment.fulfillmentServiceLevel) {
+                result += `Service Level: ${order.fulfillment.fulfillmentServiceLevel}\n`;
+            }
+        }
+        if (order.orderItems && order.orderItems.length > 0) {
+            result += `\n**Order Items (${order.orderItems.length})**\n\n`;
+            order.orderItems.forEach((item, index) => {
+                result += `**${index + 1}. ${item.product?.title || "Unknown Product"}**\n`;
+                result += `   Order Item ID: ${item.orderItemId}\n`;
+                result += `   ASIN: ${item.product?.asin || "N/A"}\n`;
+                result += `   SKU: ${item.product?.sellerSku || "N/A"}\n`;
+                result += `   Quantity Ordered: ${item.quantityOrdered}\n`;
+                if (item.product?.price?.unitPrice) {
+                    const price = item.product.price.unitPrice;
+                    result += `   Unit Price: ${price.amount} ${price.currencyCode}\n`;
+                }
+                if (item.fulfillment) {
+                    result += `   Fulfilled: ${item.fulfillment.quantityFulfilled || 0}\n`;
+                    result += `   Unfulfilled: ${item.fulfillment.quantityUnfulfilled || 0}\n`;
+                }
+                result += "\n";
+            });
+        }
+        return result;
+    }
+    formatRegulatedInfoResponse(data) {
+        if (!data) {
+            return "No regulated information found for this order.";
+        }
+        let result = `📋 **Regulated Order Information**\n\n`;
+        result += "=".repeat(50) + "\n\n";
+        if (data.regulatedInformation) {
+            const info = data.regulatedInformation;
+            if (info.verificationStatus) {
+                result += `**Verification Status**\n`;
+                result += `Status: ${info.verificationStatus.status}\n`;
+                if (info.verificationStatus.validUntil) {
+                    result += `Valid Until: ${new Date(info.verificationStatus.validUntil).toLocaleString()}\n`;
+                }
+                if (info.verificationStatus.rejectionReason) {
+                    result += `Rejection Reason: ${info.verificationStatus.rejectionReason.rejectionReasonDescription}\n`;
+                }
+                result += "\n";
+            }
+            if (info.regulatedOrderItems && info.regulatedOrderItems.length > 0) {
+                result += `**Regulated Items (${info.regulatedOrderItems.length})**\n\n`;
+                info.regulatedOrderItems.forEach((item, index) => {
+                    result += `**${index + 1}. ${item.title || "Unknown Item"}**\n`;
+                    result += `   Order Item ID: ${item.orderItemId}\n`;
+                    result += `   ASIN: ${item.asin}\n`;
+                    result += `   Quantity Ordered: ${item.quantityOrdered}\n`;
+                    if (item.verificationStatus) {
+                        result += `   Verification Status: ${item.verificationStatus.status}\n`;
+                    }
+                    if (item.fulfillmentInstructions) {
+                        result += `   Fulfillment Instructions:\n`;
+                        if (item.fulfillmentInstructions.fulfillmentInstructionsType) {
+                            result += `      Type: ${item.fulfillmentInstructions.fulfillmentInstructionsType}\n`;
+                        }
+                        if (item.fulfillmentInstructions.fulfillmentInstructionsText) {
+                            result += `      Text: ${item.fulfillmentInstructions.fulfillmentInstructionsText}\n`;
+                        }
+                    }
+                    result += "\n";
+                });
+            }
+        }
+        if (data.errors && data.errors.length > 0) {
+            result += `**Errors**\n`;
+            data.errors.forEach((error) => {
+                result += `- Code: ${error.code}, Message: ${error.message}\n`;
+            });
+        }
+        return result;
+    }
+}

package/dist/tools/migration-assistant-tools/migration-tools.d.ts

@@ -0,0 +1,21 @@
+export interface MigrationAssistantArgs {
+    source_code?: string;
+    source_version: string;
+    target_version: string;
+    language?: string;
+    analysis_only?: boolean;
+}
+export interface ToolResponse {
+    content: Array<{
+        type: "text";
+        text: string;
+        meta?: Record<string, unknown>;
+    }>;
+    isError?: boolean;
+    [key: string]: unknown;
+}
+export declare class SPAPIMigrationAssistantTool {
+    migrationAssistant(args: MigrationAssistantArgs): Promise<ToolResponse>;
+    private handleOrdersApiMigration;
+}
+//# sourceMappingURL=migration-tools.d.ts.map

package/dist/tools/migration-assistant-tools/migration-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-tools.d.ts","sourceRoot":"","sources":["../../../src/tools/migration-assistant-tools/migration-tools.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAChC,CAAC,CAAC;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,qBAAa,2BAA2B;IAChC,kBAAkB,CACtB,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,YAAY,CAAC;YA8DV,wBAAwB;CAkDvC"}

package/dist/tools/migration-assistant-tools/migration-tools.js

@@ -0,0 +1,82 @@
+import { getOrdersApiMigrationData } from "./orders-api-migration/migration-data.js";
+import { analyzeOrdersApiCode } from "./orders-api-migration/code-analyzer.js";
+import { generateRefactoredOrdersApiCode } from "./orders-api-migration/code-generator.js";
+import { formatAnalysisReport, formatMigrationReport, } from "./orders-api-migration/report-formatter.js";
+import { formatGeneralGuidance } from "./orders-api-migration/guidance-formatter.js";
+export class SPAPIMigrationAssistantTool {
+    async migrationAssistant(args) {
+        const { source_code, source_version, target_version, analysis_only = false, } = args;
+        // Validate supported migrations
+        const supportedMigrations = {
+            "orders-v0->orders-2026-01-01": {
+                source: "orders-v0",
+                target: "orders-2026-01-01",
+            },
+        };
+        const isSupported = Object.values(supportedMigrations).some((m) => m.source === source_version && m.target === target_version);
+        if (!isSupported) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Unsupported migration path: ${source_version} → ${target_version}\n\nSupported migrations:\n${Object.values(supportedMigrations)
+                            .map((m) => `- ${m.source} → ${m.target}`)
+                            .join("\n")}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Route to appropriate migration handler
+        if (source_version === "orders-v0" &&
+            target_version === "orders-2026-01-01") {
+            return this.handleOrdersApiMigration(source_code, target_version, analysis_only);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Migration handler not implemented for ${source_version} → ${target_version}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    async handleOrdersApiMigration(sourceCode, targetVersion, analysisOnly) {
+        // Get migration data
+        const migrationData = getOrdersApiMigrationData();
+        // If no source code provided, return general guidance
+        if (!sourceCode) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatGeneralGuidance(migrationData),
+                    },
+                ],
+            };
+        }
+        // Analyze the source code
+        const analysis = analyzeOrdersApiCode(sourceCode, migrationData);
+        if (analysisOnly) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatAnalysisReport(analysis, migrationData),
+                    },
+                ],
+            };
+        }
+        // Generate refactored code
+        const refactoredCode = generateRefactoredOrdersApiCode(sourceCode, analysis, targetVersion);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatMigrationReport(analysis, refactoredCode, migrationData),
+                },
+            ],
+        };
+    }
+}

package/dist/tools/migration-assistant-tools/orders-api-migration/code-analyzer.d.ts

@@ -0,0 +1,19 @@
+import { MigrationData } from "./migration-data.js";
+export interface CodeAnalysis {
+    deprecatedEndpoints: Array<{
+        endpoint: string;
+        replacement: string;
+    }>;
+    breakingChanges: Array<{
+        change: string;
+        explanation: string;
+    }>;
+    usedAttributes: Array<{
+        v0: string;
+        v1: string;
+        notes: string;
+    }>;
+    apiCalls: string[];
+}
+export declare function analyzeOrdersApiCode(sourceCode: string, migrationData: MigrationData): CodeAnalysis;
+//# sourceMappingURL=code-analyzer.d.ts.map

package/dist/tools/migration-assistant-tools/orders-api-migration/code-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/tools/migration-assistant-tools/orders-api-migration/code-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,WAAW,YAAY;IAC3B,mBAAmB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtE,eAAe,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,cAAc,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,aAAa,GAC3B,YAAY,CA2Dd"}

package/dist/tools/migration-assistant-tools/orders-api-migration/code-analyzer.js

@@ -0,0 +1,52 @@
+export function analyzeOrdersApiCode(sourceCode, migrationData) {
+    const deprecatedEndpoints = [];
+    const breakingChanges = [];
+    const usedAttributes = [];
+    const apiCalls = [];
+    // Detect API method calls
+    const apiMethodPatterns = Object.keys(migrationData.apiMapping);
+    apiMethodPatterns.forEach((method) => {
+        const regex = new RegExp(`\\b${method}\\b`, "g");
+        if (regex.test(sourceCode)) {
+            apiCalls.push(method);
+            const mapping = migrationData.apiMapping[method];
+            if (mapping.status.includes("❌")) {
+                deprecatedEndpoints.push({
+                    endpoint: method,
+                    replacement: mapping.v1,
+                });
+                breakingChanges.push({
+                    change: `${method} has no V1 counterpart`,
+                    explanation: mapping.notes,
+                });
+            }
+        }
+    });
+    // Detect deprecated attributes
+    migrationData.deprecated.forEach((attr) => {
+        const regex = new RegExp(`\\b${attr.replace(/\./g, "\\.")}\\b`, "g");
+        if (regex.test(sourceCode)) {
+            breakingChanges.push({
+                change: `Deprecated attribute: ${attr}`,
+                explanation: "This attribute is removed in V1 and has no replacement",
+            });
+        }
+    });
+    // Detect attribute mappings
+    Object.entries(migrationData.mappingExamples).forEach(([v0, v1]) => {
+        const regex = new RegExp(`\\b${v0.replace(/\./g, "\\.")}\\b`, "g");
+        if (regex.test(sourceCode)) {
+            usedAttributes.push({
+                v0,
+                v1,
+                notes: `Mapped from ${v0} to ${v1}`,
+            });
+        }
+    });
+    return {
+        deprecatedEndpoints,
+        breakingChanges,
+        usedAttributes,
+        apiCalls,
+    };
+}

package/dist/tools/migration-assistant-tools/orders-api-migration/code-generator.d.ts

@@ -0,0 +1,3 @@
+import { CodeAnalysis } from "./code-analyzer.js";
+export declare function generateRefactoredOrdersApiCode(sourceCode: string, analysis: CodeAnalysis, targetVersion: string): string;
+//# sourceMappingURL=code-generator.d.ts.map

package/dist/tools/migration-assistant-tools/orders-api-migration/code-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../../../src/tools/migration-assistant-tools/orders-api-migration/code-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,YAAY,EACtB,aAAa,EAAE,MAAM,GACpB,MAAM,CAyDR"}