Logic Apps Migration Agent

VS Code Extension for migrating BizTalk, MuleSoft, TIBCO, and other integration platforms to Azure Logic Apps Standard

Watch the Demo

See the extension in action before you install it.

Click the preview image above to open the demo video: logic-apps-migration-agent-demo.mp4

Overview

The Logic Apps Migration Agent is a VS Code extension that automates the migration of enterprise integration solutions to Azure Logic Apps Standard. It uses AI-powered analysis via GitHub Copilot to guide you through a structured migration workflow — all running locally within VS Code.

Supported Source Platforms

Partial support includes platform detection, built-in parsing, and platform-specific guidance across the migration workflow. Coverage of source components and generated mappings continues to expand.

This is an open-source project — contributions are welcome! To add support for a new platform, see Contributing a New Platform.

Target Platform

• Azure Logic Apps Standard (Workflow Service Plan)

Features

Migration Stages

The extension guides you through a 5-stage migration workflow:

Discovery → Planning → Conversion → Validation → Deployment

Quick Start

1. Install the extension from VS Code Marketplace
2. Open your BizTalk, MuleSoft, or TIBCO project folder in VS Code
3. Click the Logic Apps Migration Agent icon in the Activity Bar
4. Select your source folder when prompted (or use the command palette: Logic Apps Migration Agent: Select Source Folder)
5. Follow the guided 5-stage workflow

Requirements

Extension Settings

Configure via Settings > Extensions > Logic Apps Migration Agent:

Command Palette

Architecture

Parser System

Parsers are TypeScript modules that transform source platform artifacts into a common Intermediate Representation (IR). The extension uses a registry-based architecture supporting both built-in and external parsers.

┌─────────────────────────────────────────────────────────────┐
│                    Parser Registry                          │
├─────────────────────────────────────────────────────────────┤
│  Built-in Parsers          │  External Parser Plugins       │
│  ─────────────────         │  ──────────────────────        │
│  • BizTalk (.btproj, .odx) │  • Partner Platform Parsers    │
│  • BizTalk (.btm, .xsd)   │  • Community Parsers           │
│  • BizTalk (.btp, bindings)│                                │
│  • MuleSoft flows/projects │                                │
│  • TIBCO processes/projects│                                │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │  IR Document    │
                    │  (JSON Schema)  │
                    └─────────────────┘

AI Agents

The extension provisions three GitHub Copilot agents into your workspace:

LM Tools

The extension registers 25 Language Model tools with VS Code that the AI agents use to read artifacts, store results, and manage the migration workflow.

Source Flow Visualization

The Flow Visualizer provides an interactive webview for exploring your integration architecture. It displays data from parsed IR documents, bindings, dependency graphs, and AI-generated analysis.

Visualization Tabs

Diagram Features

• Interactive Mermaid diagrams with zoom/pan
• Dark/light theme support
• Copilot chat integration — discuss or correct any flow group
• Badge indicators for gaps, dependencies, and patterns

Migration tests

Run the BizTalk and TIBCO stage tests before submitting a pull request:

npm ci --ignore-scripts
npm test

This strictly compiles TypeScript and runs all unit and stage-handoff integration tests. The tests use fixed agent responses; they do not call Copilot or Azure. Skipped and focused (.only) tests fail the suite.

The Migration tests GitHub Actions check runs for every pull request targeting main (the default branch) or master, pushes to those branches, and merge-queue requests, without path filters.

Repository administrator setup: after the check first runs, configure an active branch ruleset for main under Settings > Rules > Rulesets. Require a pull request, require the Migration tests status check, and require branches to be up to date. Keep existing required checks and prevent bypasses so direct pushes cannot skip the tests. Apply the same rules to master if that branch is used. Adding the workflow alone does not make its result mandatory for merging.

Contributing a New Platform

This project is open-source and designed for extensibility. There are two ways to add support for a new integration platform:

Built-in parsers are the recommended approach — they ship with the extension, get the same CI/CD, and have access to all internal APIs.

What You Need to Add

To fully support a new platform (e.g., IBM IIB, Boomi, Workato), you need:

1. A built-in parser — parses source artifacts into IR documents
2. Platform-specific skills — AI instructions for each migration stage
3. Platform detection — auto-detect the platform from file patterns

Step 1: Add a Built-in Parser

Create a new parser under src/parsers//:

src/parsers/
├── biztalk/           # Reference implementation
│   ├── index.ts
│   ├── types.ts
│   ├── BizTalkProjectParser.ts
│   ├── BizTalkOrchestrationParser.ts
│   └── ...
├── /   # Your new parser
│   ├── index.ts
│   ├── types.ts
│   └── YourPlatformParser.ts

Each parser must implement the IParser interface:

import { IParser, ParserCapabilities, ParseResult, ParseOptions } from '../types';
import { IRDocument, createEmptyIRDocument } from '../../ir/types';

export class YourPlatformParser implements IParser {
    get capabilities(): ParserCapabilities {
        return {
            platform: 'your-platform',
            fileExtensions: ['.yourext'],
            fileTypes: ['flow'],
            supportsFolder: false,
            description: 'Parses YourPlatform integration flows',
        };
    }

    canParse(filePath: string): boolean {
        return filePath.endsWith('.yourext');
    }

    async parse(filePath: string, options?: ParseOptions): Promise {
        const ir = createEmptyIRDocument();
        // Parse the source file and populate the IR document
        // See docs/IRSchema.md for the complete schema
        // See docs/IRExamples_*.md for platform-specific examples
        return { ir, stats: { ... } };
    }
}

Then register it in src/parsers/index.ts:

import { YourPlatformParser } from './your-platform';

export function initializeParsers(): void {
    // ... existing parsers ...
    defaultParserRegistry.register(new YourPlatformParser());
}

Reference: See the BizTalk parser implementation in src/parsers/biztalk/ for a fully working example.

Step 2: Add Platform-Specific Skills

Skills are Markdown files that provide AI instructions for each stage of the migration. They tell the Copilot agents how to analyze, plan, and convert artifacts for your specific platform.

Skills are organized under resources/skills/, with platform-specific variants:

resources/skills/
├── detect-logical-groups/
│   ├── biztalk/SKILL.md          # BizTalk-specific rules
│   ├── mulesoft/SKILL.md         # MuleSoft-specific rules
│   └── /SKILL.md  # Your platform rules
├── source-to-logic-apps-mapping/
│   ├── biztalk/SKILL.md
│   ├── mulesoft/SKILL.md
│   └── /SKILL.md
├── msmq-built-in-connector/
│   └── SKILL.md                 # Shared MSMQ connector rules
├── soap-built-in-connector/
│   └── SKILL.md                 # Shared SOAP connector rules
└── ... (16 skills total)

Skill Format

Each SKILL.md uses YAML frontmatter followed by Markdown content:

---
name: source-to-logic-apps-mapping
description: One-to-one mapping of every YourPlatform component to its Azure Logic Apps Standard equivalent.
---

# YourPlatform to Azure Logic Apps Standard — Component Migration Reference

> Mapping of YourPlatform components to Logic Apps equivalents.

## Adapter Mappings

| YourPlatform Component | Logic Apps Equivalent | Native? | Notes           |
| ---------------------- | --------------------- | ------- | --------------- |
| HTTP Listener          | HTTP Trigger          | Yes     | Native built-in |
| Database Connector     | SQL Server connector  | Yes     | Native built-in |

...

Required Skills (16 total)

Create a /SKILL.md variant for each platform-specific skill. The MSMQ and SOAP built-in connector skills are shared fallbacks and apply whenever a platform maps a source component to those connectors.

Tip: Copy an existing platform’s skills as a starting point (e.g., biztalk/SKILL.md) and adapt the content for your platform.

Step 3: Register the Platform

Add your platform to the supported platforms list in src/types/platforms.ts:

export type SourcePlatform = 'biztalk' | 'mulesoft' | 'your-platform';

export const SUPPORTED_PLATFORMS: PlatformInfo[] = [
    // ... existing platforms ...
    {
        id: 'your-platform',
        label: 'YourPlatform',
        description: 'YourPlatform version X',
        icon: '$(server)',
        filePatterns: ['.yourext', '.yourconfig'],
    },
];

Also add detection logic in src/stages/discovery/PlatformDetector.ts and file patterns in src/stages/discovery/SourceFolderService.ts.

Step 4: Add IR Examples (Optional but Recommended)

Add a docs/IRExamples_YourPlatform.md documenting how your platform’s artifacts map to the IR schema. The existing examples serve as templates:

• docs/IRExamples_BizTalk.md — BizTalk reference
• docs/IRExamples_MuleSoft.md — MuleSoft reference
• docs/IRExamples_Boomi.md — Dell Boomi example
• docs/IRExamples_IBMIIB.md — IBM IIB/ACE example
• docs/IRExamples_TIBCO.md — TIBCO BusinessWorks example
• docs/IRExamples_Workato.md — Workato example

Alternative: External Parser Extension

If you prefer not to contribute directly to this repo, you can create a separate VS Code extension that registers parsers via the plugin API:

import * as vscode from 'vscode';

export async function activate(context: vscode.ExtensionContext) {
    const assistant = vscode.extensions.getExtension('ms-azuretools.logicapps-migration-agent');

    if (assistant) {
        const api = await assistant.activate();
        api.registerParser(new MyPlatformParser(), { priority: 10 });
    }
}

Note: External parser extensions only cover the Discovery stage (parsing source files). Skills, platform detection, and AI-powered planning/conversion require contributing to this repo directly.

Parser Plugin API

IR Schema

All parsers must output documents conforming to the IR (Intermediate Representation) schema. See docs/IRSchema.md for the complete specification.

Project Structure

src/
├── extension.ts              # Extension entry point
├── commands/                  # Command palette commands
├── constants/                 # Prompts and user messages
├── copilot/                   # Copilot integration (LM tools, context builder)
├── errors/                    # Error types and handler
├── ir/                        # Intermediate Representation (types, validation, serialization)
├── parsers/                   # Parser system (BizTalk, MuleSoft, TIBCO, plugin loader)
├── services/                  # Core services (state, config, logging, telemetry)
├── stages/                    # Stage implementations (discovery, planning, conversion)
├── types/                     # Shared type definitions
├── ui/                        # Sidebar tree providers
└── views/                     # Webview panels (discovery, planning, conversion)

resources/
├── agents/                    # Copilot agent prompt files (migration-analyser, planner, converter)
├── icons/                     # Extension and activity bar icons
├── referenceDocs/             # BizTalk and Logic Apps reference documentation
├── referenceWorkflowsAndConnections/  # Reference Logic Apps workflow templates
└── skills/                    # Platform-specific AI skills (13 skills × N platforms)

docs/
├── IRSchema.md                # IR schema specification (complete v3 reference)
├── IRExamples_BizTalk.md      # BizTalk IR examples
├── IRExamples_MuleSoft.md     # MuleSoft IR examples
├── IRExamples_Boomi.md        # Dell Boomi IR examples (reference for contributors)
├── IRExamples_IBMIIB.md       # IBM IIB/ACE IR examples (reference for contributors)
├── IRExamples_TIBCO.md        # TIBCO BW IR examples (reference for contributors)
├── IRExamples_Workato.md      # Workato IR examples (reference for contributors)
├── SourceFlowVisualization.md # Source flow visualization documentation
└── UserFlow.md                # User flow documentation

License

MIT License — see LICENSE for details.