Workflow Converter

Bidirectional workflow converter across automation platforms.

Vision

Build an engine that converts workflows Make → n8n and n8n → Make reliably, with full mapping traceability and AI support to accelerate conversion when exact rules are missing.

After stabilizing Make/n8n, scale to similar platforms (e.g., Zapier, Pipedream, Node-RED, etc.) using the same architecture.

MVP Goals (Phase 1)

• Bidirectional conversion: Make <-> n8n.
• Normalization into a canonical intermediate format (IR: Intermediate Representation).
• Versioned mapping catalog (nodes, fields, expressions, auth, triggers).
• Conversion compatibility report:
  • exact: 1:1 mapping
  • partial: partial mapping with warnings
  • unsupported: unsupported with suggestion
• AI-assisted mode to:
  • Complete mapping suggestions when exact rules do not exist.
  • Generate replacement recommendations for modules/nodes.
  • Explain conversion decisions.

Design Principles

1. Deterministic first, AI second

   • Prefer explicit rules.
   • Use AI only as a suggestion/help layer, never as the single source of truth.

2. Full traceability

   • Every converted field should include:
     • rule used,
     • confidence level,
     • notes.

3. Connector-based extensibility

   • Each platform is integrated as an adapter (import/export).
   • The engine works against IR, not directly against proprietary payloads.

4. Versioned mappings and schemas

   • Prevent breakage when platform APIs evolve.

Proposed Architecture

Source Workflow (Make/n8n)
        |
        v
 [Source Adapter]
        |
        v
  Intermediate Representation (IR)
        |
        +--> Validation + Lint + Diff
        |
        +--> Mapping Engine (rule-based)
        |         |
        |         +--> AI Assist (fallback / suggestions)
        |
        v
 [Target Adapter]
        |
        v
Target Workflow (n8n/Make)

Main Components

• src/features/conversion/*

  • IR building, rule application, and target payload export.

• src/features/mapping/*

  • Versioned capabilities/rules catalogs + deterministic resolver.

• src/features/platform/*

  • Platform detection and payload parsing/validation (Make/n8n).

• src/features/validation/*

  • Shape validation and consistency checks.

• src/shared/*

  • Cross-feature infrastructure (I/O, shared utilities).

• src/app/app-container.factory.ts

  • DI composition root that wires all services.

Mapping Strategy

1. Parse source payload into IR.
2. Apply exact rules by node/module/field.
3. Mark gaps and ambiguities.
4. If ai-assist is enabled, request structured suggestions.
5. Validate suggestions against target constraints.
6. Generate target workflow + conversion report.

AI Support (Claude / Claude Code / others)

The system exposes a clear contract for AI assistance:

• Controlled input: IR fragment + node context + target capabilities.
• Structured output: JSON proposal with rationale and confidence.
• Guardrails:
  • never apply AI output without validation,
  • never auto-overwrite existing exact rules,
  • log relevant prompts/responses for auditability.

Roadmap

Phase 1 — Foundations (Make <-> n8n)

• Define IR v0.
• Implement basic Make and n8n import/export.
• Create initial critical mapping catalog.
• Generate conversion report.

Phase 2 — Quality and DX

• CLI: convert, validate, diff, explain.
• Test suite with real cases.
• Mapping coverage metrics.

Phase 3 — AI Assisted

• Suggestion mode with approval flow.
• Confidence ranking + alternatives.
• Learning from approved mappings (human-curated).

Phase 4 — Multi-platform Scaling

• Plugin system for new adapters.
• Add Zapier/Pipedream/Node-RED (priority-based).

Initial Success Criteria

• Convert common Make↔n8n workflows with high fidelity.
• Clear report of what was converted and what was not.
• Short onboarding time to add new mappings.

Public Project

• License: MIT
• Contribution guide: CONTRIBUTING.md
• Initial release plan: docs/release-plan-v0.1.0.md

IDE and AI Rules

• Project-wide rules: AGENTS.md
• GitHub Copilot: .github/copilot-instructions.md
• Claude / Claude Code: CLAUDE.md
• Cursor: .cursor/rules/architecture.mdc

Recommended Next Step

Move into technical definition of:

1. IR v0 schema.
2. mapping rule contract.
3. conversion report format.
4. ai-assist input/output contract.

CLI (Initial MVP)

A base CLI is available for conversion and validation.

Installation

npm install
npm run build

Quality and Architecture

# Verify architecture rules (feature-first, DI, no legacy)
npm run arch:check

# Run full local quality pipeline (guard + typecheck + build)
npm run ci

Commands

# Convert Make -> n8n
npx wfconv convert --from make --to n8n -i examples/make-sample.json -o out/n8n.json -r out/report.json

# Convert n8n -> Make
npx wfconv convert --from n8n --to make -i examples/n8n-sample.json -o out/make.json -r out/report.json

# Validate workflow shape
npx wfconv validate -i examples/make-sample.json --platform make

# Explain conversion viability
npx wfconv explain -i examples/n8n-sample.json --from n8n --to make

# Large workflows: memory-optimized mode
npx wfconv convert --from make --to n8n --low-memory --report-level summary -i examples/make-sample.json -o out/n8n.json -r out/report.json

Note: this MVP currently provides IR normalization + basic export + reporting. Deep node/field mapping will keep expanding via the mapping catalog.

Performance Options

• --low-memory: skips raw copy in IR and omits ir from internal result to reduce memory pressure.
• --report-level full|summary: controls report size.
  • full: includes node-level items.
  • summary: summary + audit only (much lighter for large workflows).

Functional Progress (Make ↔ n8n)

Foundation Ready

• CLI convert, validate, explain
• Unified IR with nodes + connections
• Fail-closed policy by default
• Versioned catalog (capabilities + rules)
• Runtime validation with Zod (payloads + catalogs)
• Conversion report with traceability (ruleId, policy, confidence)

Common Node Coverage (Current)

• HTTP Request (make:http ↔ n8n-nodes-base.httpRequest)
• Webhook (make:webhook ↔ n8n-nodes-base.webhook)
• Router/Switch (make:router ↔ n8n-nodes-base.switch)
• IF (make:router ↔ n8n-nodes-base.if) (partial)
• Set/Tools (make:tools ↔ n8n-nodes-base.set)
• Wait/Sleep (make:sleep ↔ n8n-nodes-base.wait)
• Scheduler (make:scheduler ↔ n8n-nodes-base.scheduleTrigger)
• Code/JSON (make:json ↔ n8n-nodes-base.code) (partial)

Open Collaboration Priorities

1. Credential/auth mapping per connector.
2. Advanced expressions and conditions (normalization + translation).
3. Complex connections (multi-output branching edge cases).
4. Unit/integration/e2e tests with real fixtures.
5. Expand catalog coverage for top community-used nodes.